gerrit.onap Code Review - portal/sdk.git/blob

   1 /*
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal SDK
   4  * ===================================================================
   5  * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   8  * Unless otherwise specified, all software contained herein is licensed
   9  * under the Apache License, Version 2.0 (the "License");
  10  * you may not use this software except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * Unless otherwise specified, all documentation contained herein is licensed
  22  * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
  23  * you may not use this documentation except in compliance with the License.
  24  * You may obtain a copy of the License at
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  28  * Unless required by applicable law or agreed to in writing, documentation
  29  * distributed under the License is distributed on an "AS IS" BASIS,
  30  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  * See the License for the specific language governing permissions and
  32  * limitations under the License.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  37  */
  38 package org.onap.portalsdk.analytics.xmlobj;
  39
  40 import static org.junit.Assert.*;
  41
  42 import java.sql.Connection;
  43 import java.util.ArrayList;
  44 import java.util.List;
  45 import java.util.Vector;
  46 import java.util.concurrent.Semaphore;
  47
  48 import javax.servlet.http.HttpServletRequest;
  49 import javax.servlet.http.HttpServletResponse;
  50 import javax.xml.bind.JAXBException;
  51
  52 import org.junit.Before;
  53 import org.junit.Test;
  54 import org.junit.runner.RunWith;
  55 import org.mockito.Matchers;
  56 import org.mockito.Mock;
  57 import org.mockito.Mockito;
  58 import org.mockito.MockitoAnnotations;
  59 import org.onap.portalsdk.analytics.controller.WizardSequence;
  60 import org.onap.portalsdk.analytics.error.RaptorException;
  61 import org.onap.portalsdk.analytics.error.ReportSQLException;
  62 import org.onap.portalsdk.analytics.error.UserAccessException;
  63 import org.onap.portalsdk.analytics.error.ValidationException;
  64 import org.onap.portalsdk.analytics.model.DataCache;
  65 import org.onap.portalsdk.analytics.model.ReportLoader;
  66 import org.onap.portalsdk.analytics.model.base.IdNameValue;
  67 import org.onap.portalsdk.analytics.model.base.ReportWrapper;
  68 import org.onap.portalsdk.analytics.model.definition.DBColumnInfo;
  69 import org.onap.portalsdk.analytics.model.definition.ReportDefinition;
  70 import org.onap.portalsdk.analytics.model.definition.ReportSchedule;
  71 import org.onap.portalsdk.analytics.system.AppUtils;
  72 import org.onap.portalsdk.analytics.system.DbUtils;
  73 import org.onap.portalsdk.analytics.system.Globals;
  74 import org.onap.portalsdk.analytics.util.AppConstants;
  75 import org.onap.portalsdk.analytics.util.DataSet;
  76 import org.onap.portalsdk.analytics.util.Utils;
  77 import org.onap.portalsdk.analytics.xmlobj.CustomReportType;
  78 import org.onap.portalsdk.analytics.xmlobj.DataColumnList;
  79 import org.onap.portalsdk.analytics.xmlobj.DataColumnType;
  80 import org.onap.portalsdk.analytics.xmlobj.DataSourceList;
  81 import org.onap.portalsdk.analytics.xmlobj.DataSourceType;
  82 import org.onap.portalsdk.analytics.xmlobj.FormFieldList;
  83 import org.powermock.api.mockito.PowerMockito;
  84 import org.powermock.core.classloader.annotations.PrepareForTest;
  85 import org.powermock.modules.junit4.PowerMockRunner;
  86
  87 @RunWith(PowerMockRunner.class)
  88 @PrepareForTest({ AppConstants.class, Globals.class, DataSet.class, DataCache.class, DbUtils.class, AppUtils.class,
  89                 ReportLoader.class, Utils.class })
  90 public class ReportDefinitionTest {
  91
  92         @Before
  93         public void setup() {
  94                 MockitoAnnotations.initMocks(this);
  95         }
  96
  97         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  98         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  99         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
 100
 101         public ReportDefinition mockReportDefinition() throws RaptorException {
 102                 PowerMockito.mockStatic(Globals.class);
 103                 PowerMockito.mockStatic(DbUtils.class);
 104                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 105                 DataSet datset = PowerMockito.mock(DataSet.class);
 106                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 107                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 108                 CustomReportType customReportType = new CustomReportType();
 109                 customReportType.setReportType("test");
 110                 FormFieldList formFieldList = new FormFieldList();
 111                 formFieldList.setComment("test");
 112                 customReportType.setFormFieldList(formFieldList);
 113                 customReportType.setPublic(true);
 114                 DataSourceList dataSourceList = new DataSourceList();
 115
 116                 List<DataSourceType> list = new ArrayList<>();
 117                 DataSourceType dataSourceType = new DataSourceType();
 118                 // dataSourceType.setTableName("test");
 119                 // dataSourceType.setRefTableId("1");
 120                 // dataSourceType.setTableId("1");
 121                 List<DataColumnType> dataColumnTypeList = new ArrayList<>();
 122                 // DataColumnType dataColumnType = new DataColumnType();
 123                 // dataColumnType.setChartGroup("test");
 124                 // dataColumnType.setYAxis("test");
 125                 // dataColumnType.setColName("[test");
 126                 // dataColumnType.setColOnChart("LEGEND");
 127                 // dataColumnType.setDisplayName("chart_total");
 128                 // dataColumnType.setColId("1");
 129                 // dataColumnType.setTableId("1");
 130                 // dataColumnType.setColType("DATE");
 131                 // dataColumnTypeList.add(dataColumnType);
 132                 DataColumnList dataColumnList = new DataColumnList();
 133                 // dataColumnList.dataColumn = dataColumnTypeList;
 134                 dataSourceType.setDataColumnList(dataColumnList);
 135                 list.add(dataSourceType);
 136                 dataSourceList.dataSource = list;
 137                 customReportType.setReportType("test");
 138                 customReportType.setReportTitle("test");
 139                 customReportType.setDataSourceList(dataSourceList);
 140
 141                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 142                                 "1", true);
 143                 reportWrapper.setReportDefType("SQL-based");
 144                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 145
 146                 return reportDefinition;
 147         }
 148
 149         @Test(expected = UserAccessException.class)
 150         public void setAsCopyException() throws Exception {
 151                 ReportDefinition reportDefinition = mockReportDefinition();
 152                 PowerMockito.mockStatic(AppUtils.class);
 153                 PowerMockito.mockStatic(Globals.class);
 154
 155                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test");
 156                 Mockito.when(Globals.getAllowSQLBasedReports()).thenReturn(false);
 157                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(false);
 158                 Mockito.when(AppUtils.getUserName(mockedRequest)).thenReturn("test");
 159                 reportDefinition.setAsCopy(mockedRequest);
 160         }
 161
 162         @Test
 163         public void setAsCopyRaptorExceptionTest() throws Exception {
 164                 ReportDefinition reportDefinition = mockReportDefinition();
 165                 PowerMockito.mockStatic(AppUtils.class);
 166                 PowerMockito.mockStatic(Globals.class);
 167                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test");
 168                 Mockito.when(Globals.getAllowSQLBasedReports()).thenReturn(true);
 169                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 170                 Mockito.when(AppUtils.getUserName(mockedRequest)).thenReturn("test");
 171                 reportDefinition.setAsCopy(mockedRequest);
 172         }
 173
 174         @Test
 175         public void setAsCopyTest() throws Exception {
 176                 ReportDefinition reportDefinition = mockReportDefinition();
 177                 PowerMockito.mockStatic(AppUtils.class);
 178                 PowerMockito.mockStatic(Globals.class);
 179                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test");
 180                 Mockito.when(Globals.getAllowSQLBasedReports()).thenReturn(true);
 181                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 182                 Mockito.when(AppUtils.getUserName(mockedRequest)).thenReturn("test");
 183                 reportDefinition.setAsCopy(mockedRequest);
 184         }
 185
 186         @Test
 187         public void getWizardSequenceTest() throws Exception {
 188                 ReportDefinition reportDefinition = mockReportDefinition();
 189                 assertEquals(reportDefinition.getWizardSequence().getClass(), WizardSequence.class);
 190         }
 191
 192         @Test
 193         public void generateWizardSequenceIfReportTypeLinear() throws Exception {
 194                 PowerMockito.mockStatic(Globals.class);
 195                 PowerMockito.mockStatic(DbUtils.class);
 196                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 197                 DataSet datset = PowerMockito.mock(DataSet.class);
 198                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 199                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 200                 CustomReportType customReportType = mockcustomReportwithDataSource();
 201                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 202                                 "1", true);
 203                 reportWrapper.setReportDefType("SQL-based");
 204                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 205                 PowerMockito.mockStatic(AppUtils.class);
 206                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 207                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 208                 reportDefinition.generateWizardSequence(mockedRequest);
 209         }
 210
 211         @Test
 212         public void generateWizardSequenceIfReportTypeSQLbased() throws Exception {
 213                 PowerMockito.mockStatic(Globals.class);
 214                 PowerMockito.mockStatic(DbUtils.class);
 215                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 216                 DataSet datset = PowerMockito.mock(DataSet.class);
 217                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 218                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 219                 CustomReportType customReportType = mockcustomReportwithDataSource();
 220                 customReportType.setReportType("Linear");
 221                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 222                                 "1", true);
 223                 reportWrapper.setReportDefType("SQL-based_Datamining");
 224                 reportWrapper.setReportDefType("SQL-based");
 225                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 226                 PowerMockito.mockStatic(AppUtils.class);
 227                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 228                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 229                 reportDefinition.generateWizardSequence(mockedRequest);
 230         }
 231
 232         @Test
 233         public void generateWizardSequenceIfReportTypeSQLbasedDatamining() throws Exception {
 234                 PowerMockito.mockStatic(Globals.class);
 235                 PowerMockito.mockStatic(DbUtils.class);
 236                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 237                 DataSet datset = PowerMockito.mock(DataSet.class);
 238                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 239                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 240                 CustomReportType customReportType = mockcustomReportwithDataSource();
 241                 customReportType.setReportType("Linear");
 242                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 243                                 "1", true);
 244                 reportWrapper.setReportDefType("SQL-based_Datamining");
 245                 reportWrapper.setReportDefType("SQL-based_Datamining");
 246                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 247                 PowerMockito.mockStatic(AppUtils.class);
 248                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 249                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 250                 reportDefinition.generateWizardSequence(mockedRequest);
 251         }
 252
 253         @Test
 254         public void generateWizardSequenceIfReportTypeCrossTab() throws Exception {
 255                 PowerMockito.mockStatic(Globals.class);
 256                 PowerMockito.mockStatic(DbUtils.class);
 257                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 258                 DataSet datset = PowerMockito.mock(DataSet.class);
 259                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 260                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 261                 CustomReportType customReportType = mockcustomReportwithDataSource();
 262                 customReportType.setReportType("Cross-Tab");
 263                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 264                                 "1", true);
 265                 reportWrapper.setReportDefType("SQL-based");
 266                 reportWrapper.setReportDefType("SQL-based");
 267                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 268                 PowerMockito.mockStatic(AppUtils.class);
 269                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 270                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 271                 reportDefinition.generateWizardSequence(mockedRequest);
 272         }
 273
 274         @Test
 275         public void generateWizardSequenceIfReportTypeCrossTab1() throws Exception {
 276                 PowerMockito.mockStatic(Globals.class);
 277                 PowerMockito.mockStatic(DbUtils.class);
 278                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 279                 DataSet datset = PowerMockito.mock(DataSet.class);
 280                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 281                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 282                 CustomReportType customReportType = mockcustomReportwithDataSource();
 283                 customReportType.setReportType("Cross-Tab");
 284                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 285                                 "1", true);
 286                 reportWrapper.setReportDefType("SQL-based1");
 287                 reportWrapper.setReportDefType("SQL-based1");
 288                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 289                 PowerMockito.mockStatic(AppUtils.class);
 290                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 291                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 292                 reportDefinition.generateWizardSequence(mockedRequest);
 293         }
 294
 295         @Test
 296         public void generateWizardSequenceIfReportTypeDAshboard() throws Exception {
 297                 PowerMockito.mockStatic(Globals.class);
 298                 PowerMockito.mockStatic(DbUtils.class);
 299                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 300                 DataSet datset = PowerMockito.mock(DataSet.class);
 301                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 302                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 303                 CustomReportType customReportType = mockcustomReportwithDataSource();
 304                 customReportType.setReportType("Dashboard");
 305                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 306                                 "1", true);
 307                 reportWrapper.setReportDefType("SQL-based1");
 308                 reportWrapper.setReportDefType("SQL-based1");
 309                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 310                 PowerMockito.mockStatic(AppUtils.class);
 311                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 312                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 313                 reportDefinition.generateWizardSequence(mockedRequest);
 314         }
 315
 316         @Test
 317         public void generateWizardSequenceIfReportTypeHive() throws Exception {
 318                 PowerMockito.mockStatic(Globals.class);
 319                 PowerMockito.mockStatic(DbUtils.class);
 320                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 321                 DataSet datset = PowerMockito.mock(DataSet.class);
 322                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 323                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 324                 CustomReportType customReportType = mockcustomReportwithDataSource();
 325                 customReportType.setReportType("Hive");
 326                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 327                                 "1", true);
 328                 reportWrapper.setReportDefType("SQL-based1");
 329                 reportWrapper.setReportDefType("SQL-based1");
 330                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 331                 PowerMockito.mockStatic(AppUtils.class);
 332                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 333                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 334                 reportDefinition.generateWizardSequence(mockedRequest);
 335         }
 336
 337         @Test
 338         public void persistReportExceptionTest() throws Exception {
 339                 ReportDefinition reportDefinition = mockReportDefinition();
 340                 reportDefinition.persistReport(mockedRequest);
 341         }
 342
 343         @Test
 344         public void persistReportTest() throws Exception {
 345                 PowerMockito.mockStatic(Globals.class);
 346
 347                 PowerMockito.mockStatic(AppUtils.class);
 348                 PowerMockito.mockStatic(DbUtils.class);
 349                 PowerMockito.mockStatic(Utils.class);
 350
 351                 PowerMockito.mockStatic(ReportLoader.class);
 352                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test");
 353                 Mockito.when(Globals.getNewReportData()).thenReturn("test");
 354
 355                 Connection connection = PowerMockito.mock(Connection.class);
 356                 Mockito.when(DbUtils.startTransaction()).thenReturn(connection);
 357                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 358                 DataSet datset = PowerMockito.mock(DataSet.class);
 359                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 360                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 361                 CustomReportType customReportType = mockcustomReportwithDataSource();
 362                 customReportType.setReportType("Cross-Tab");
 363                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 364                                 "1", true);
 365                 reportWrapper.setReportDefType("SQL-based_Datamining");
 366                 reportWrapper.setReportDefType("SQL-based");
 367                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 368                 Mockito.when(DbUtils.executeQuery(Matchers.any(Connection.class), Matchers.anyString())).thenReturn(datset);
 369                 PowerMockito.doNothing().when(ReportLoader.class);
 370                 ReportLoader.createCustomReportRec(Matchers.any(Connection.class), Matchers.any(ReportWrapper.class),
 371                                 Matchers.anyString());
 372                 ReportLoader.createReportLogEntry(Matchers.any(Connection.class), Matchers.anyString(), Matchers.anyString(),
 373                                 Matchers.anyString(), Matchers.anyString(), Matchers.anyString());
 374                 Mockito.when(Utils.getCurrentDateTime()).thenReturn("test");
 375                 ReportSchedule reportSchedule = reportDefinition.getReportSchedule();
 376                 reportSchedule = PowerMockito.mock(ReportSchedule.class);
 377                 Mockito.doNothing().when(reportSchedule).persistScheduleData(Matchers.any(Connection.class),
 378                                 Matchers.any(HttpServletRequest.class));
 379                 reportDefinition.persistReport(mockedRequest);
 380         }
 381
 382         @Test
 383         public void persistReport1Test() throws Exception {
 384                 PowerMockito.mockStatic(Globals.class);
 385
 386                 PowerMockito.mockStatic(AppUtils.class);
 387                 PowerMockito.mockStatic(DbUtils.class);
 388                 PowerMockito.mockStatic(Utils.class);
 389
 390                 PowerMockito.mockStatic(ReportLoader.class);
 391                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test");
 392                 Mockito.when(Globals.getNewReportData()).thenReturn("test");
 393
 394                 Connection connection = PowerMockito.mock(Connection.class);
 395                 Mockito.when(DbUtils.startTransaction()).thenReturn(connection);
 396                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 397                 DataSet datset = PowerMockito.mock(DataSet.class);
 398                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 399                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 400                 CustomReportType customReportType = mockcustomReportwithDataSource();
 401                 customReportType.setReportType("Cross-Tab");
 402                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "1", "test", "testId", "test", "test", "1",
 403                                 "1", true);
 404                 reportWrapper.setReportDefType("SQL-based_Datamining");
 405                 reportWrapper.setReportDefType("SQL-based");
 406                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 407                 Mockito.when(DbUtils.executeQuery(Matchers.any(Connection.class), Matchers.anyString())).thenReturn(datset);
 408                 PowerMockito.doNothing().when(ReportLoader.class);
 409                 ReportLoader.updateCustomReportRec(Matchers.any(Connection.class), Matchers.any(ReportWrapper.class),
 410                                 Matchers.anyString());
 411                 Mockito.when(Utils.getCurrentDateTime()).thenReturn("test");
 412                 ReportSchedule reportSchedule = reportDefinition.getReportSchedule();
 413                 reportSchedule = PowerMockito.mock(ReportSchedule.class);
 414                 Mockito.doNothing().when(reportSchedule).persistScheduleData(Matchers.any(Connection.class),
 415                                 Matchers.any(HttpServletRequest.class));
 416                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test");
 417                 Mockito.when(Globals.getAllowSQLBasedReports()).thenReturn(true);
 418                 Mockito.when(AppUtils.isAdminUser(mockedRequest)).thenReturn(true);
 419                 Mockito.when(AppUtils.getUserName(mockedRequest)).thenReturn("test");
 420                 reportDefinition.persistReport(mockedRequest);
 421         }
 422
 423         public CustomReportType mockcustomReport() {
 424                 CustomReportType customReportType = new CustomReportType();
 425                 FormFieldList formFieldList = new FormFieldList();
 426                 formFieldList.setComment("test");
 427                 customReportType.setFormFieldList(formFieldList);
 428                 customReportType.setPublic(true);
 429                 DataSourceList dataSourceList = new DataSourceList();
 430                 List<DataSourceType> list = new ArrayList<>();
 431                 DataSourceType dataSourceType = new DataSourceType();
 432                 List<DataColumnType> dataColumnTypeList = new ArrayList<>();
 433                 DataColumnList dataColumnList = new DataColumnList();
 434                 dataSourceType.setDataColumnList(dataColumnList);
 435                 list.add(dataSourceType);
 436                 dataSourceList.dataSource = list;
 437                 customReportType.setReportType("Linear");
 438                 customReportType.setReportTitle("test");
 439                 customReportType.setDataSourceList(dataSourceList);
 440                 return customReportType;
 441
 442         }
 443
 444         public CustomReportType mockcustomReportwithDataSource() {
 445                 CustomReportType customReportType = new CustomReportType();
 446                 List<FormFieldType> formfild = new ArrayList<>();
 447                 FormFieldType formFieldType = new FormFieldType();
 448                 formFieldType.setColId("1");
 449                 formfild.add(formFieldType);
 450                 FormFieldList formFieldList = new FormFieldList();
 451                 formFieldList.setComment("test");
 452                 formFieldList.formField = formfild;
 453                 JavascriptList javascriptList = new JavascriptList();
 454                 customReportType.setJavascriptList(javascriptList);
 455                 customReportType.setFormFieldList(formFieldList);
 456                 customReportType.setPublic(true);
 457                 DataSourceList dataSourceList = new DataSourceList();
 458
 459                 List<DataSourceType> list = new ArrayList<>();
 460                 DataSourceType dataSourceType = new DataSourceType();
 461                 dataSourceType.setTableName("test");
 462                 dataSourceType.setRefTableId("1");
 463                 dataSourceType.setTableId("1");
 464                 List<DataColumnType> dataColumnTypeList = new ArrayList<>();
 465                 DataColumnType dataColumnType = new DataColumnType();
 466                 dataColumnType.setChartGroup("test");
 467                 dataColumnType.setYAxis("test");
 468                 dataColumnType.setColName("[test");
 469                 dataColumnType.setColOnChart("LEGEND");
 470                 dataColumnType.setDisplayName("chart_total");
 471                 dataColumnType.setColId("1");
 472                 dataColumnType.setTableId("1");
 473                 dataColumnType.setColType("DATE");
 474                 dataColumnType.setOrderBySeq(1);
 475                 dataColumnType.setCrossTabValue("ROW");
 476                 dataColumnTypeList.add(dataColumnType);
 477                 DataColumnType dataColumnType1 = new DataColumnType();
 478                 dataColumnType1.setCrossTabValue("COLUMN");
 479                 dataColumnType1.setColId("1");
 480                 dataColumnType1.setOrderBySeq(1);
 481                 dataColumnTypeList.add(dataColumnType1);
 482                 DataColumnType dataColumnType2 = new DataColumnType();
 483                 dataColumnType2.setCrossTabValue("VALUE");
 484                 dataColumnType2.setColId("1");
 485                 dataColumnType2.setOrderBySeq(2);
 486                 dataColumnTypeList.add(dataColumnType2);
 487                 DataColumnList dataColumnList = new DataColumnList();
 488                 dataColumnList.dataColumn = dataColumnTypeList;
 489                 dataSourceType.setDataColumnList(dataColumnList);
 490                 list.add(dataSourceType);
 491                 dataSourceList.dataSource = list;
 492                 dataSourceList.dataSource = list;
 493                 customReportType.setReportType("Linear");
 494                 customReportType.setReportTitle("test");
 495                 customReportType.setDataSourceList(dataSourceList);
 496                 customReportType.setFormFieldList(formFieldList);
 497                 return customReportType;
 498
 499         }
 500
 501         public FormatList mockFormatList() {
 502                 FormatList formatList = new FormatList();
 503                 List<FormatType> format = new ArrayList<>();
 504                 FormatType formatType = new FormatType();
 505                 formatType.setFormatId("null_fmt1");
 506                 FormatType formatType1 = new FormatType();
 507                 formatType1.setFormatId("1");
 508                 format.add(formatType);
 509                 format.add(formatType1);
 510                 formatList.format = format;
 511                 return formatList;
 512         }
 513
 514         public JavascriptList mockJavascriptList() {
 515                 JavascriptList javascriptList = new JavascriptList();
 516
 517                 List<JavascriptItemType> list1 = new ArrayList<>();
 518                 JavascriptItemType javascriptItemType = new JavascriptItemType();
 519                 javascriptItemType.setFieldId("1");
 520                 javascriptItemType.setId("1");
 521                 list1.add(javascriptItemType);
 522                 javascriptList.javascriptItem = list1;
 523                 return javascriptList;
 524         }
 525
 526         public ColFilterList mockColFilterList() {
 527                 ColFilterList colFilterList = new ColFilterList();
 528                 List<ColFilterType> colFilter = new ArrayList<>();
 529                 ColFilterType colFilterType = new ColFilterType();
 530                 colFilterType.setColId("1");
 531                 colFilterType.setArgType("FORM");
 532                 colFilterType.setArgValue("test");
 533                 colFilter.add(colFilterType);
 534                 colFilterList.colFilter = colFilter;
 535                 return colFilterList;
 536
 537         }
 538
 539         public CustomReportType mockcustomReportwithDataSource1() {
 540                 CustomReportType customReportType = new CustomReportType();
 541                 List<FormFieldType> formfild = new ArrayList<>();
 542                 FormFieldType formFieldType = new FormFieldType();
 543                 formFieldType.setColId("1");
 544                 formFieldType.setFieldId("ff1");
 545                 formFieldType.setOrderBySeq(4);
 546                 formfild.add(formFieldType);
 547                 FormFieldList formFieldList = new FormFieldList();
 548                 formFieldList.setComment("test");
 549                 formFieldList.formField = formfild;
 550                 JavascriptList javascriptList = mockJavascriptList();
 551                 customReportType.setJavascriptList(javascriptList);
 552                 customReportType.setFormFieldList(formFieldList);
 553                 customReportType.setPublic(true);
 554                 List<SemaphoreType> semList = new ArrayList<>();
 555                 SemaphoreList semaphoreList = new SemaphoreList();
 556                 SemaphoreType semaphore = new SemaphoreType();
 557                 semaphore.setSemaphoreId("1");
 558                 semaphore.setFormatList(mockFormatList());
 559                 SemaphoreType semaphore1 = new SemaphoreType();
 560                 semaphore1.setSemaphoreId("sem1");
 561                 semaphore1.setFormatList(mockFormatList());
 562                 semList.add(semaphore);
 563                 semList.add(semaphore1);
 564                 semaphoreList.semaphore = semList;
 565                 customReportType.setSemaphoreList(semaphoreList);
 566                 DataSourceList dataSourceList = new DataSourceList();
 567
 568                 List<DataSourceType> list = new ArrayList<>();
 569                 DataSourceType dataSourceType = new DataSourceType();
 570                 dataSourceType.setTableName("test");
 571                 dataSourceType.setRefTableId("1");
 572                 dataSourceType.setTableId("1");
 573                 List<DataColumnType> dataColumnTypeList = new ArrayList<>();
 574                 DataColumnType dataColumnType = new DataColumnType();
 575                 dataColumnType.setChartGroup("test");
 576                 dataColumnType.setYAxis("test");
 577                 dataColumnType.setColName("[test");
 578                 dataColumnType.setColOnChart("LEGEND");
 579                 dataColumnType.setDisplayName("chart_total");
 580                 dataColumnType.setColId("1");
 581                 dataColumnType.setTableId("1");
 582                 dataColumnType.setColType("DATE");
 583                 dataColumnType.setCrossTabValue("ROW");
 584                 dataColumnType.setCalculated(true);
 585                 dataColumnType.setColFilterList(mockColFilterList());
 586                 dataColumnTypeList.add(dataColumnType);
 587                 DataColumnType dataColumnType1 = new DataColumnType();
 588                 dataColumnType1.setCrossTabValue("COLUMN");
 589                 dataColumnType1.setColId("1");
 590                 dataColumnTypeList.add(dataColumnType1);
 591
 592                 DataColumnType dataColumnType2 = new DataColumnType();
 593                 dataColumnType2.setCrossTabValue("VALUE");
 594                 dataColumnType2.setColId("1");
 595
 596                 dataColumnTypeList.add(dataColumnType2);
 597
 598                 DataColumnList dataColumnList = new DataColumnList();
 599                 dataColumnList.dataColumn = dataColumnTypeList;
 600                 dataSourceType.setDataColumnList(dataColumnList);
 601                 list.add(dataSourceType);
 602                 dataSourceList.dataSource = list;
 603                 dataSourceList.dataSource = list;
 604                 customReportType.setReportType("Linear");
 605                 customReportType.setReportTitle("test");
 606                 customReportType.setDataSourceList(dataSourceList);
 607                 customReportType.setFormFieldList(formFieldList);
 608                 return customReportType;
 609
 610         }
 611
 612         @Test
 613         public void getCrossTabDisplayValueROWTest() throws Exception {
 614                 PowerMockito.mockStatic(Globals.class);
 615                 PowerMockito.mockStatic(DbUtils.class);
 616                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 617                 DataSet datset = PowerMockito.mock(DataSet.class);
 618                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 619                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 620                 CustomReportType customReportType = mockcustomReportwithDataSource();
 621                 customReportType.setReportType("Hive");
 622                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 623                                 "1", true);
 624                 reportWrapper.setReportDefType("SQL-based1");
 625                 reportWrapper.setReportDefType("SQL-based1");
 626                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 627                 assertEquals(reportDefinition.getCrossTabDisplayValue("ROW"), "Row headings");
 628         }
 629
 630         @Test
 631         public void getCrossTabDisplayValueCOLUMNTest() throws Exception {
 632                 PowerMockito.mockStatic(Globals.class);
 633                 PowerMockito.mockStatic(DbUtils.class);
 634                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 635                 DataSet datset = PowerMockito.mock(DataSet.class);
 636                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 637                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 638                 CustomReportType customReportType = mockcustomReportwithDataSource();
 639                 customReportType.setReportType("Hive");
 640                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 641                                 "1", true);
 642                 reportWrapper.setReportDefType("SQL-based1");
 643                 reportWrapper.setReportDefType("SQL-based1");
 644                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 645                 assertEquals(reportDefinition.getCrossTabDisplayValue("COLUMN"), "Column headings");
 646         }
 647
 648         @Test
 649         public void getCrossTabDisplayValueTest() throws Exception {
 650                 PowerMockito.mockStatic(Globals.class);
 651                 PowerMockito.mockStatic(DbUtils.class);
 652                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 653                 DataSet datset = PowerMockito.mock(DataSet.class);
 654                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 655                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 656                 CustomReportType customReportType = mockcustomReportwithDataSource();
 657                 customReportType.setReportType("Hive");
 658                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 659                                 "1", true);
 660                 reportWrapper.setReportDefType("SQL-based1");
 661                 reportWrapper.setReportDefType("SQL-based1");
 662                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 663                 assertEquals(reportDefinition.getCrossTabDisplayValue("VALUE"), "Report values");
 664         }
 665
 666         @Test
 667         public void getCrossTabDisplayTest() throws Exception {
 668                 PowerMockito.mockStatic(Globals.class);
 669                 PowerMockito.mockStatic(DbUtils.class);
 670                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 671                 DataSet datset = PowerMockito.mock(DataSet.class);
 672                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 673                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 674                 CustomReportType customReportType = mockcustomReportwithDataSource();
 675                 customReportType.setReportType("Hive");
 676                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 677                                 "1", true);
 678                 reportWrapper.setReportDefType("SQL-based1");
 679                 reportWrapper.setReportDefType("SQL-based1");
 680                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 681                 assertEquals(reportDefinition.getCrossTabDisplayValue("Test"), "Invisible/Filter");
 682         }
 683
 684         @Test
 685         public void getCrossTabDisplayValue() throws Exception {
 686                 PowerMockito.mockStatic(Globals.class);
 687                 PowerMockito.mockStatic(DbUtils.class);
 688                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 689                 DataSet datset = PowerMockito.mock(DataSet.class);
 690                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 691                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 692                 CustomReportType customReportType = mockcustomReportwithDataSource();
 693                 customReportType.setReportType("Hive");
 694                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 695                                 "1", true);
 696                 reportWrapper.setReportDefType("SQL-based1");
 697                 reportWrapper.setReportDefType("SQL-based1");
 698                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 699                 DataColumnType dataColumnType1 = new DataColumnType();
 700                 dataColumnType1.setCrossTabValue("COLUMN");
 701                 assertEquals(reportDefinition.getCrossTabDisplayValue(dataColumnType1), "Column headings");
 702         }
 703
 704         @Test
 705         public void getColumnLabelTest() throws Exception {
 706                 PowerMockito.mockStatic(Globals.class);
 707                 PowerMockito.mockStatic(DbUtils.class);
 708                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 709                 DataSet datset = PowerMockito.mock(DataSet.class);
 710                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 711                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 712                 CustomReportType customReportType = mockcustomReportwithDataSource();
 713                 customReportType.setReportType("Hive");
 714                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 715                                 "1", true);
 716                 reportWrapper.setReportDefType("SQL-based1");
 717                 reportWrapper.setReportDefType("SQL-based1");
 718                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 719                 DataColumnType dataColumnType1 = new DataColumnType();
 720                 dataColumnType1.setCrossTabValue("COLUMN");
 721                 dataColumnType1.setTableId("1");
 722                 Vector vector = PowerMockito.mock(Vector.class);
 723                 PowerMockito.mockStatic(DataCache.class);
 724
 725                 Mockito.when(DataCache.getReportTableDbColumns(Matchers.anyString(), Matchers.anyString())).thenReturn(vector);
 726                 assertEquals(reportDefinition.getColumnLabel(dataColumnType1), "");
 727         }
 728
 729         @Test
 730         public void getColumnLabelNewTest() throws Exception {
 731                 PowerMockito.mockStatic(Globals.class);
 732                 PowerMockito.mockStatic(DbUtils.class);
 733                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 734                 DataSet datset = PowerMockito.mock(DataSet.class);
 735                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 736                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 737                 CustomReportType customReportType = mockcustomReportwithDataSource();
 738                 customReportType.setReportType("Hive");
 739                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 740                                 "1", true);
 741                 reportWrapper.setReportDefType("SQL-based1");
 742                 reportWrapper.setReportDefType("SQL-based1");
 743                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 744                 DataColumnType dataColumnType1 = new DataColumnType();
 745                 dataColumnType1.setCrossTabValue("COLUMN");
 746                 dataColumnType1.setTableId("1");
 747                 dataColumnType1.setDbColName("test");
 748                 Vector vector = new Vector<>();
 749                 DBColumnInfo DBColumnInfo = new DBColumnInfo("test", "test", "test", "test");
 750                 vector.add(DBColumnInfo);
 751                 PowerMockito.mockStatic(DataCache.class);
 752
 753                 Mockito.when(DataCache.getReportTableDbColumns(Matchers.anyString(), Matchers.anyString())).thenReturn(vector);
 754                 assertEquals(reportDefinition.getColumnLabel(dataColumnType1), "test");
 755         }
 756
 757         @Test
 758         public void getFilterLabelTest() throws Exception {
 759                 PowerMockito.mockStatic(Globals.class);
 760                 PowerMockito.mockStatic(DbUtils.class);
 761                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 762                 DataSet datset = PowerMockito.mock(DataSet.class);
 763                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 764                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 765                 CustomReportType customReportType = mockcustomReportwithDataSource();
 766                 customReportType.setReportType("Hive");
 767                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 768                                 "1", true);
 769                 reportWrapper.setReportDefType("SQL-based1");
 770                 reportWrapper.setReportDefType("SQL-based1");
 771                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 772                 ColFilterType colFilterType = new ColFilterType();
 773                 colFilterType.setExpression("test");
 774                 assertEquals(reportDefinition.getFilterLabel(colFilterType), "test ");
 775         }
 776
 777         @Test
 778         public void getFilterLabel1Test() throws Exception {
 779                 PowerMockito.mockStatic(Globals.class);
 780                 PowerMockito.mockStatic(DbUtils.class);
 781                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 782                 DataSet datset = PowerMockito.mock(DataSet.class);
 783                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 784                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 785                 CustomReportType customReportType = mockcustomReportwithDataSource();
 786                 customReportType.setReportType("Hive");
 787                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 788                                 "1", true);
 789                 reportWrapper.setReportDefType("SQL-based1");
 790                 reportWrapper.setReportDefType("SQL-based1");
 791                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 792                 ColFilterType colFilterType = new ColFilterType();
 793                 colFilterType.setExpression("test");
 794                 colFilterType.setArgType("FORMULA");
 795                 assertEquals(reportDefinition.getFilterLabel(colFilterType), "test [null]");
 796         }
 797
 798         @Test
 799         public void getFilterLabel2Test() throws Exception {
 800                 PowerMockito.mockStatic(Globals.class);
 801                 PowerMockito.mockStatic(DbUtils.class);
 802                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 803                 DataSet datset = PowerMockito.mock(DataSet.class);
 804                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 805                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 806                 CustomReportType customReportType = mockcustomReportwithDataSource();
 807                 customReportType.setReportType("Hive");
 808                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 809                                 "1", true);
 810                 reportWrapper.setReportDefType("SQL-based1");
 811                 reportWrapper.setReportDefType("SQL-based1");
 812                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 813                 ColFilterType colFilterType = new ColFilterType();
 814                 colFilterType.setExpression("test");
 815                 colFilterType.setArgType("VALUE");
 816                 assertEquals(reportDefinition.getFilterLabel(colFilterType), "test null");
 817         }
 818
 819         @Test
 820         public void getFilterLabel3Test() throws Exception {
 821                 PowerMockito.mockStatic(Globals.class);
 822                 PowerMockito.mockStatic(DbUtils.class);
 823                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 824                 DataSet datset = PowerMockito.mock(DataSet.class);
 825                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 826                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 827                 CustomReportType customReportType = mockcustomReportwithDataSource();
 828                 customReportType.setReportType("Hive");
 829                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 830                                 "1", true);
 831                 reportWrapper.setReportDefType("SQL-based1");
 832                 reportWrapper.setReportDefType("SQL-based1");
 833                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 834                 ColFilterType colFilterType = new ColFilterType();
 835                 colFilterType.setExpression("test");
 836                 colFilterType.setArgType("LIST");
 837                 assertEquals(reportDefinition.getFilterLabel(colFilterType), "test (null)");
 838         }
 839
 840         @Test
 841         public void getFilterLabel4Test() throws Exception {
 842                 PowerMockito.mockStatic(Globals.class);
 843                 PowerMockito.mockStatic(DbUtils.class);
 844                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 845                 DataSet datset = PowerMockito.mock(DataSet.class);
 846                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 847                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 848                 CustomReportType customReportType = mockcustomReportwithDataSource();
 849                 customReportType.setReportType("Hive");
 850                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 851                                 "1", true);
 852                 reportWrapper.setReportDefType("SQL-based1");
 853                 reportWrapper.setReportDefType("SQL-based1");
 854                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 855                 ColFilterType colFilterType = new ColFilterType();
 856                 colFilterType.setExpression("test");
 857                 colFilterType.setArgType("LIST");
 858                 assertEquals(reportDefinition.getFilterLabel(colFilterType), "test (null)");
 859         }
 860
 861         @Test
 862         public void getFilterLabel5Test() throws Exception {
 863                 PowerMockito.mockStatic(Globals.class);
 864                 PowerMockito.mockStatic(DbUtils.class);
 865                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 866                 DataSet datset = PowerMockito.mock(DataSet.class);
 867                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 868                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 869                 CustomReportType customReportType = mockcustomReportwithDataSource();
 870                 customReportType.setReportType("Hive");
 871                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 872                                 "1", true);
 873                 reportWrapper.setReportDefType("SQL-based1");
 874                 reportWrapper.setReportDefType("SQL-based1");
 875                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 876                 ColFilterType colFilterType = new ColFilterType();
 877                 colFilterType.setExpression("test");
 878                 colFilterType.setArgType("COLUMN");
 879                 colFilterType.setArgValue("1");
 880                 assertEquals(reportDefinition.getFilterLabel(colFilterType), "test [chart_total]");
 881         }
 882
 883         @Test
 884         public void getFilterLabel6Test() throws Exception {
 885                 PowerMockito.mockStatic(Globals.class);
 886                 PowerMockito.mockStatic(DbUtils.class);
 887                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 888                 DataSet datset = PowerMockito.mock(DataSet.class);
 889                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 890                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 891                 CustomReportType customReportType = mockcustomReportwithDataSource();
 892                 customReportType.setReportType("Hive");
 893                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 894                                 "1", true);
 895                 reportWrapper.setReportDefType("SQL-based1");
 896                 reportWrapper.setReportDefType("SQL-based1");
 897                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 898                 ColFilterType colFilterType = new ColFilterType();
 899                 colFilterType.setExpression("test");
 900                 colFilterType.setArgType("FORM");
 901                 colFilterType.setArgValue("1");
 902                 assertEquals(reportDefinition.getFilterLabel(colFilterType), "test [Form Field]");
 903         }
 904
 905         @Test
 906         public void getReportUsersTest() throws Exception {
 907                 PowerMockito.mockStatic(Globals.class);
 908                 PowerMockito.mockStatic(DbUtils.class);
 909                 PowerMockito.mockStatic(AppUtils.class);
 910                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 911                 DataSet datset = PowerMockito.mock(DataSet.class);
 912                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 913                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 914                 CustomReportType customReportType = mockcustomReportwithDataSource();
 915                 customReportType.setReportType("Hive");
 916                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 917                                 "1", true);
 918                 reportWrapper.setReportDefType("SQL-based1");
 919                 reportWrapper.setReportDefType("SQL-based1");
 920                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 921                 Mockito.when(Globals.getCustomizedScheduleQueryForUsers()).thenReturn("test");
 922                 Mockito.when(Globals.getSessionParams()).thenReturn("test,1");
 923                 Mockito.when(AppUtils.getUserBackdoorLoginId(mockedRequest)).thenReturn("test");
 924                 Vector vc = new Vector<>();
 925                 IdNameValue idNameValue = new IdNameValue();
 926                 idNameValue.setId("1");
 927                 vc.add(idNameValue);
 928                 Mockito.when(AppUtils.getAllUsers(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean()))
 929                                 .thenReturn(vc);
 930                 assertEquals(reportDefinition.getReportUsers(mockedRequest).getClass(), Vector.class);
 931         }
 932
 933         @Test
 934         public void getReportRolesTest() throws Exception {
 935                 PowerMockito.mockStatic(Globals.class);
 936                 PowerMockito.mockStatic(DbUtils.class);
 937                 PowerMockito.mockStatic(AppUtils.class);
 938                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 939                 DataSet datset = PowerMockito.mock(DataSet.class);
 940                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 941                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 942                 CustomReportType customReportType = mockcustomReportwithDataSource();
 943                 customReportType.setReportType("Hive");
 944                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 945                                 "1", true);
 946                 reportWrapper.setReportDefType("SQL-based1");
 947                 reportWrapper.setReportDefType("SQL-based1");
 948                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 949                 Mockito.when(Globals.getCustomizedScheduleQueryForUsers()).thenReturn("test");
 950                 Mockito.when(Globals.getSessionParams()).thenReturn("test,1");
 951                 Mockito.when(AppUtils.getUserBackdoorLoginId(mockedRequest)).thenReturn("test");
 952                 Vector vc = new Vector<>();
 953                 IdNameValue idNameValue = new IdNameValue();
 954                 idNameValue.setId("1");
 955                 vc.add(idNameValue);
 956                 Mockito.when(AppUtils.getAllRoles(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean()))
 957                                 .thenReturn(vc);
 958                 assertEquals(reportDefinition.getReportRoles(mockedRequest).getClass(), Vector.class);
 959         }
 960
 961         @Test
 962         public void clearAllDrillDownsTest() throws Exception {
 963                 PowerMockito.mockStatic(Globals.class);
 964                 PowerMockito.mockStatic(DbUtils.class);
 965                 PowerMockito.mockStatic(AppUtils.class);
 966                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 967                 DataSet datset = PowerMockito.mock(DataSet.class);
 968                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 969                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 970                 CustomReportType customReportType = mockcustomReportwithDataSource();
 971                 customReportType.setReportType("Hive");
 972                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 973                                 "1", true);
 974                 reportWrapper.setReportDefType("SQL-based1");
 975                 reportWrapper.setReportDefType("SQL-based1");
 976                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 977                 reportDefinition.clearAllDrillDowns();
 978
 979         }
 980
 981         @Test
 982         public void setOuterJoinTest() throws Exception {
 983                 PowerMockito.mockStatic(Globals.class);
 984                 PowerMockito.mockStatic(DbUtils.class);
 985                 PowerMockito.mockStatic(AppUtils.class);
 986                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 987                 DataSet datset = PowerMockito.mock(DataSet.class);
 988                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 989                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 990                 CustomReportType customReportType = mockcustomReportwithDataSource();
 991                 customReportType.setReportType("Hive");
 992                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 993                                 "1", true);
 994                 reportWrapper.setReportDefType("SQL-based1");
 995                 reportWrapper.setReportDefType("SQL-based1");
 996                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 997                 DataSourceType dataSourceType = new DataSourceType();
 998                 dataSourceType.setTableName("test");
 999                 dataSourceType.setRefTableId("1");
1000                 dataSourceType.setTableId("1");
1001                 reportDefinition.setOuterJoin(dataSourceType, "test");
1002         }
1003
1004         @Test
1005         public void setOuterJoin1Test() throws Exception {
1006                 PowerMockito.mockStatic(Globals.class);
1007                 PowerMockito.mockStatic(DbUtils.class);
1008                 PowerMockito.mockStatic(AppUtils.class);
1009                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1010                 DataSet datset = PowerMockito.mock(DataSet.class);
1011                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1012                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1013                 CustomReportType customReportType = mockcustomReportwithDataSource();
1014                 customReportType.setReportType("Hive");
1015                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1016                                 "1", true);
1017                 reportWrapper.setReportDefType("SQL-based1");
1018                 reportWrapper.setReportDefType("SQL-based1");
1019                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1020                 DataSourceType dataSourceType = new DataSourceType();
1021                 dataSourceType.setTableName("test");
1022                 dataSourceType.setRefTableId("1");
1023                 dataSourceType.setTableId("1");
1024                 dataSourceType.setRefDefinition("test= (+)1=");
1025                 reportDefinition.setOuterJoin(dataSourceType, "test");
1026         }
1027
1028         @Test
1029         public void setOuterJoin2Test() throws Exception {
1030                 PowerMockito.mockStatic(Globals.class);
1031                 PowerMockito.mockStatic(DbUtils.class);
1032                 PowerMockito.mockStatic(AppUtils.class);
1033                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1034                 DataSet datset = PowerMockito.mock(DataSet.class);
1035                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1036                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1037                 CustomReportType customReportType = mockcustomReportwithDataSource();
1038                 customReportType.setReportType("Hive");
1039                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1040                                 "1", true);
1041                 reportWrapper.setReportDefType("SQL-based1");
1042                 reportWrapper.setReportDefType("SQL-based1");
1043                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1044                 DataSourceType dataSourceType = new DataSourceType();
1045                 dataSourceType.setTableName("test");
1046                 dataSourceType.setRefTableId("1");
1047                 dataSourceType.setTableId("1");
1048                 dataSourceType.setRefDefinition("test= (+)1=");
1049                 reportDefinition.setOuterJoin(dataSourceType, "CURRENT");
1050         }
1051
1052         @Test
1053         public void setOuterJoin3Test() throws Exception {
1054                 PowerMockito.mockStatic(Globals.class);
1055                 PowerMockito.mockStatic(DbUtils.class);
1056                 PowerMockito.mockStatic(AppUtils.class);
1057                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1058                 DataSet datset = PowerMockito.mock(DataSet.class);
1059                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1060                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1061                 CustomReportType customReportType = mockcustomReportwithDataSource();
1062                 customReportType.setReportType("Hive");
1063                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1064                                 "1", true);
1065                 reportWrapper.setReportDefType("SQL-based1");
1066                 reportWrapper.setReportDefType("SQL-based1");
1067                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1068                 DataSourceType dataSourceType = new DataSourceType();
1069                 dataSourceType.setTableName("test");
1070                 dataSourceType.setRefTableId("1");
1071                 dataSourceType.setTableId("1");
1072                 dataSourceType.setRefDefinition("test= (+)1=");
1073                 reportDefinition.setOuterJoin(dataSourceType, "JOINED");
1074         }
1075
1076         @Test
1077         public void setOuterJoin4Test() throws Exception {
1078                 PowerMockito.mockStatic(Globals.class);
1079                 PowerMockito.mockStatic(DbUtils.class);
1080                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1081                 DataSet datset = PowerMockito.mock(DataSet.class);
1082                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1083                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1084                 CustomReportType customReportType = mockcustomReportwithDataSource();
1085                 customReportType.setReportType("Hive");
1086                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1087                                 "1", true);
1088                 reportWrapper.setReportDefType("SQL-based1");
1089                 reportWrapper.setReportDefType("SQL-based1");
1090                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1091                 DataSourceType dataSourceType = new DataSourceType();
1092                 dataSourceType.setTableName("test");
1093                 dataSourceType.setRefTableId("1");
1094                 dataSourceType.setTableId("1");
1095                 dataSourceType.setRefDefinition("tes1t= (+)1=");
1096                 reportDefinition.setOuterJoin(dataSourceType, "JOINED");
1097         }
1098
1099         @Test
1100         public void setOuterJoin5Test() throws Exception {
1101                 PowerMockito.mockStatic(Globals.class);
1102                 PowerMockito.mockStatic(DbUtils.class);
1103                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1104                 DataSet datset = PowerMockito.mock(DataSet.class);
1105                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1106                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1107                 CustomReportType customReportType = mockcustomReportwithDataSource();
1108                 customReportType.setReportType("Hive");
1109                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1110                                 "1", true);
1111                 reportWrapper.setReportDefType("SQL-based1");
1112                 reportWrapper.setReportDefType("SQL-based1");
1113                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1114                 DataSourceType dataSourceType = new DataSourceType();
1115                 dataSourceType.setTableName("test");
1116                 dataSourceType.setRefTableId("1");
1117                 dataSourceType.setTableId("1");
1118                 dataSourceType.setRefDefinition("tes1t= (+)1=");
1119                 reportDefinition.setOuterJoin(dataSourceType, "CURRENT");
1120         }
1121
1122         @Test
1123         public void addDataSourceTypeTest() throws Exception {
1124                 PowerMockito.mockStatic(Globals.class);
1125                 PowerMockito.mockStatic(DbUtils.class);
1126                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1127                 DataSet datset = PowerMockito.mock(DataSet.class);
1128                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1129                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1130                 CustomReportType customReportType = mockcustomReportwithDataSource();
1131                 customReportType.setReportType("Hive");
1132                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1133                                 "1", true);
1134                 reportWrapper.setReportDefType("SQL-based1");
1135                 reportWrapper.setReportDefType("SQL-based1");
1136                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1137                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1138                 DataSourceType dataSourceType = new DataSourceType();
1139                 dataSourceType.setTableName("test");
1140                 dataSourceType.setRefTableId("1");
1141                 dataSourceType.setTableId("1");
1142                 dataSourceType.setRefDefinition("tes1t= (+)1=");
1143                 Mockito.when(objectFactory.createDataSourceType()).thenReturn(dataSourceType);
1144                 reportDefinition.addDataSourceType(objectFactory, "1", "test", "test", "test", "2", "test", "comment");
1145         }
1146
1147         @Test
1148         public void addDataSourceType1Test() throws Exception {
1149                 PowerMockito.mockStatic(Globals.class);
1150                 PowerMockito.mockStatic(DbUtils.class);
1151                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1152                 DataSet datset = PowerMockito.mock(DataSet.class);
1153                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1154                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1155                 CustomReportType customReportType = mockcustomReportwithDataSource();
1156                 customReportType.setReportType("Hive");
1157                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1158                                 "1", true);
1159                 reportWrapper.setReportDefType("SQL-based1");
1160                 reportWrapper.setReportDefType("SQL-based1");
1161                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1162                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1163                 DataSourceType dataSourceType = new DataSourceType();
1164                 dataSourceType.setTableName("test");
1165                 dataSourceType.setRefTableId("1");
1166                 dataSourceType.setTableId("1");
1167                 dataSourceType.setRefDefinition("tes1t= (+)1=");
1168                 Mockito.when(objectFactory.createDataSourceType()).thenReturn(dataSourceType);
1169                 reportDefinition.addDataSourceType(objectFactory, "1", "test", "test", "test", "", "", "");
1170         }
1171
1172         @Test
1173         public void deleteDataSourceTypeTest() throws Exception {
1174                 PowerMockito.mockStatic(Globals.class);
1175                 PowerMockito.mockStatic(DbUtils.class);
1176                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1177                 DataSet datset = PowerMockito.mock(DataSet.class);
1178                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1179                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1180                 CustomReportType customReportType = mockcustomReportwithDataSource();
1181                 customReportType.setReportType("Hive");
1182                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1183                                 "1", true);
1184                 reportWrapper.setReportDefType("SQL-based1");
1185                 reportWrapper.setReportDefType("SQL-based1");
1186                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1187                 reportDefinition.deleteDataSourceType("1");
1188
1189         }
1190
1191         @Test
1192         public void getUniqueColumnIdTest() throws Exception {
1193                 PowerMockito.mockStatic(Globals.class);
1194                 PowerMockito.mockStatic(DbUtils.class);
1195                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1196                 DataSet datset = PowerMockito.mock(DataSet.class);
1197                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1198                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1199                 CustomReportType customReportType = mockcustomReportwithDataSource();
1200                 customReportType.setReportType("Hive");
1201                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1202                                 "1", true);
1203                 reportWrapper.setReportDefType("SQL-based1");
1204                 reportWrapper.setReportDefType("SQL-based1");
1205                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1206                 assertEquals(reportDefinition.getUniqueColumnId("test"), "te4");
1207
1208         }
1209
1210         @Test
1211         public void addDataColumnTypeTest() throws Exception {
1212                 PowerMockito.mockStatic(Globals.class);
1213                 PowerMockito.mockStatic(DbUtils.class);
1214                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1215                 DataSet datset = PowerMockito.mock(DataSet.class);
1216                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1217                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1218                 CustomReportType customReportType = mockcustomReportwithDataSource();
1219                 customReportType.setReportType("Hive");
1220                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1221                                 "1", true);
1222                 reportWrapper.setReportDefType("SQL-based1");
1223                 reportWrapper.setReportDefType("SQL-based1");
1224                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1225
1226                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1227                 DataColumnType dataColumnType = new DataColumnType();
1228                 dataColumnType.setChartGroup("test");
1229                 dataColumnType.setYAxis("test");
1230                 dataColumnType.setColName("[test");
1231                 dataColumnType.setColOnChart("LEGEND");
1232                 dataColumnType.setDisplayName("chart_total");
1233                 dataColumnType.setColId("1");
1234                 dataColumnType.setTableId("1");
1235                 dataColumnType.setColType("DATE");
1236                 Mockito.when(objectFactory.createDataColumnType()).thenReturn(dataColumnType);
1237
1238                 assertEquals(reportDefinition
1239                                 .addDataColumnType(objectFactory, "1", "1", "test", "test", "test", "test", 1, "test", 1, false, false,
1240                                                 "test", "comment", false, 1, "test", "test", "test", 1, "test", "test", "test", "test", "test")
1241                                 .getClass(), DataColumnType.class);
1242         }
1243
1244         @Test
1245         public void addDataColumnType1Test() throws Exception {
1246                 PowerMockito.mockStatic(Globals.class);
1247                 PowerMockito.mockStatic(DbUtils.class);
1248                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1249                 DataSet datset = PowerMockito.mock(DataSet.class);
1250                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1251                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1252                 CustomReportType customReportType = mockcustomReportwithDataSource();
1253                 customReportType.setReportType("Hive");
1254                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1255                                 "1", true);
1256                 reportWrapper.setReportDefType("SQL-based1");
1257                 reportWrapper.setReportDefType("SQL-based1");
1258                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1259
1260                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1261                 DataColumnType dataColumnType = new DataColumnType();
1262                 dataColumnType.setChartGroup("test");
1263                 dataColumnType.setYAxis("test");
1264                 dataColumnType.setColName("[test");
1265                 dataColumnType.setColOnChart("LEGEND");
1266                 dataColumnType.setDisplayName("chart_total");
1267                 dataColumnType.setColId("1");
1268                 dataColumnType.setTableId("1");
1269                 dataColumnType.setColType("DATE");
1270                 Mockito.when(objectFactory.createDataColumnType()).thenReturn(dataColumnType);
1271
1272                 assertEquals(reportDefinition.addDataColumnType(objectFactory, "", "1", "", "", "", "", 1, "", 1, false, false,
1273                                 "", "", false, 1, "", "", "", 1, "", "", "", "", "").getClass(), DataColumnType.class);
1274         }
1275
1276         @Test
1277         public void deleteDataColumnTypeTest() throws Exception {
1278                 PowerMockito.mockStatic(Globals.class);
1279                 PowerMockito.mockStatic(DbUtils.class);
1280                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1281                 DataSet datset = PowerMockito.mock(DataSet.class);
1282                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1283                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1284                 CustomReportType customReportType = mockcustomReportwithDataSource();
1285                 customReportType.setReportType("Hive");
1286                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1287                                 "1", true);
1288                 reportWrapper.setReportDefType("SQL-based1");
1289                 reportWrapper.setReportDefType("SQL-based1");
1290                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1291                 reportDefinition.deleteDataColumnType("1");
1292         }
1293
1294         @Test
1295         public void shiftColumnOrderUpTest() throws Exception {
1296                 PowerMockito.mockStatic(Globals.class);
1297                 PowerMockito.mockStatic(DbUtils.class);
1298                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1299                 DataSet datset = PowerMockito.mock(DataSet.class);
1300                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1301                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1302                 CustomReportType customReportType = mockcustomReportwithDataSource();
1303                 customReportType.setReportType("Hive");
1304                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1305                                 "1", true);
1306                 reportWrapper.setReportDefType("SQL-based1");
1307                 reportWrapper.setReportDefType("SQL-based1");
1308                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1309                 reportDefinition.shiftColumnOrderUp("1");
1310         }
1311
1312         @Test
1313         public void shiftColumnOrderDownTest() throws Exception {
1314                 PowerMockito.mockStatic(Globals.class);
1315                 PowerMockito.mockStatic(DbUtils.class);
1316                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1317                 DataSet datset = PowerMockito.mock(DataSet.class);
1318                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1319                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1320                 CustomReportType customReportType = mockcustomReportwithDataSource();
1321                 customReportType.setReportType("Hive");
1322                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1323                                 "1", true);
1324                 reportWrapper.setReportDefType("SQL-based1");
1325                 reportWrapper.setReportDefType("SQL-based1");
1326                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1327                 reportDefinition.shiftColumnOrderDown("1");
1328         }
1329
1330         @Test
1331         public void resetColumnOrderValuesTest() throws Exception {
1332                 PowerMockito.mockStatic(Globals.class);
1333                 PowerMockito.mockStatic(DbUtils.class);
1334                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1335                 DataSet datset = PowerMockito.mock(DataSet.class);
1336                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1337                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1338                 CustomReportType customReportType = mockcustomReportwithDataSource();
1339                 customReportType.setReportType("Hive");
1340                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1341                                 "1", true);
1342                 reportWrapper.setReportDefType("SQL-based1");
1343                 reportWrapper.setReportDefType("SQL-based1");
1344                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1345                 reportDefinition.resetColumnOrderValues();
1346         }
1347
1348         @Test
1349         public void addColFilterTypeTest() throws Exception {
1350
1351                 PowerMockito.mockStatic(Globals.class);
1352                 PowerMockito.mockStatic(DbUtils.class);
1353                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1354                 DataSet datset = PowerMockito.mock(DataSet.class);
1355                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1356                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1357                 CustomReportType customReportType = mockcustomReportwithDataSource();
1358                 customReportType.setReportType("Hive");
1359                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1360                                 "1", true);
1361                 reportWrapper.setReportDefType("SQL-based1");
1362                 reportWrapper.setReportDefType("SQL-based1");
1363                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1364                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1365                 ColFilterType colFilterType = new ColFilterType();
1366                 colFilterType.setExpression("test");
1367                 Mockito.when(objectFactory.createColFilterType()).thenReturn(colFilterType);
1368                 reportDefinition.addColFilterType(objectFactory, "", "", "", "", "", "", "", "");
1369
1370         }
1371
1372         @Test
1373         public void addColFilterType1Test() throws Exception {
1374
1375                 PowerMockito.mockStatic(Globals.class);
1376                 PowerMockito.mockStatic(DbUtils.class);
1377                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1378                 DataSet datset = PowerMockito.mock(DataSet.class);
1379                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1380                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1381                 CustomReportType customReportType = mockcustomReportwithDataSource();
1382                 customReportType.setReportType("Hive");
1383                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1384                                 "1", true);
1385                 reportWrapper.setReportDefType("SQL-based1");
1386                 reportWrapper.setReportDefType("SQL-based1");
1387                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1388                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1389                 ColFilterType colFilterType = new ColFilterType();
1390                 colFilterType.setExpression("test");
1391                 Mockito.when(objectFactory.createColFilterType()).thenReturn(colFilterType);
1392                 ColFilterList list = new ColFilterList();
1393                 Mockito.when(objectFactory.createColFilterList()).thenReturn(list);
1394                 reportDefinition.addColFilterType(objectFactory, "1", "1", "test", "test", "test", "test", "test", "test");
1395
1396         }
1397
1398         @Test
1399         public void removeColumnFilterTest() throws Exception {
1400                 PowerMockito.mockStatic(Globals.class);
1401                 PowerMockito.mockStatic(DbUtils.class);
1402                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1403                 DataSet datset = PowerMockito.mock(DataSet.class);
1404                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1405                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1406                 CustomReportType customReportType = mockcustomReportwithDataSource();
1407                 customReportType.setReportType("Hive");
1408                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1409                                 "1", true);
1410                 reportWrapper.setReportDefType("SQL-based1");
1411                 reportWrapper.setReportDefType("SQL-based1");
1412                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1413                 reportDefinition.removeColumnFilter("1", 1);
1414         }
1415
1416         @Test
1417         public void removeColumnFilter1Test() throws Exception {
1418                 PowerMockito.mockStatic(Globals.class);
1419                 PowerMockito.mockStatic(DbUtils.class);
1420                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1421                 DataSet datset = PowerMockito.mock(DataSet.class);
1422                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1423                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1424                 CustomReportType customReportType = mockcustomReportwithDataSource1();
1425                 customReportType.setReportType("Hive");
1426                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1427                                 "1", true);
1428                 reportWrapper.setReportDefType("SQL-based1");
1429                 reportWrapper.setReportDefType("SQL-based1");
1430                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1431                 reportDefinition.removeColumnFilter("1", 1);
1432         }
1433
1434         @Test
1435         public void addColumnSortTest() throws Exception {
1436                 PowerMockito.mockStatic(Globals.class);
1437                 PowerMockito.mockStatic(DbUtils.class);
1438                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1439                 DataSet datset = PowerMockito.mock(DataSet.class);
1440                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1441                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1442                 CustomReportType customReportType = mockcustomReportwithDataSource();
1443                 customReportType.setReportType("Hive");
1444                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1445                                 "1", true);
1446                 reportWrapper.setReportDefType("SQL-based1");
1447                 reportWrapper.setReportDefType("SQL-based1");
1448                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1449                 reportDefinition.addColumnSort("1", "test");
1450
1451         }
1452
1453         @Test
1454         public void removeColumnSortTest() throws Exception {
1455                 PowerMockito.mockStatic(Globals.class);
1456                 PowerMockito.mockStatic(DbUtils.class);
1457                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1458                 DataSet datset = PowerMockito.mock(DataSet.class);
1459                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1460                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1461                 CustomReportType customReportType = mockcustomReportwithDataSource();
1462                 customReportType.setReportType("Hive");
1463                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1464                                 "1", true);
1465                 reportWrapper.setReportDefType("SQL-based1");
1466                 reportWrapper.setReportDefType("SQL-based1");
1467                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1468                 reportDefinition.removeColumnSort("1");
1469
1470         }
1471
1472         @Test
1473         public void shiftColumnSortUpTest() throws Exception {
1474                 PowerMockito.mockStatic(Globals.class);
1475                 PowerMockito.mockStatic(DbUtils.class);
1476                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1477                 DataSet datset = PowerMockito.mock(DataSet.class);
1478                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1479                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1480                 CustomReportType customReportType = mockcustomReportwithDataSource();
1481                 customReportType.setReportType("Hive");
1482                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1483                                 "1", true);
1484                 reportWrapper.setReportDefType("SQL-based1");
1485                 reportWrapper.setReportDefType("SQL-based1");
1486                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1487                 reportDefinition.shiftColumnSortUp("test");
1488
1489         }
1490
1491         @Test
1492         public void shiftColumnSortDownTest() throws Exception {
1493                 PowerMockito.mockStatic(Globals.class);
1494                 PowerMockito.mockStatic(DbUtils.class);
1495                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1496                 DataSet datset = PowerMockito.mock(DataSet.class);
1497                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1498                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1499                 CustomReportType customReportType = mockcustomReportwithDataSource();
1500                 customReportType.setReportType("Hive");
1501                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1502                                 "1", true);
1503                 reportWrapper.setReportDefType("SQL-based1");
1504                 reportWrapper.setReportDefType("SQL-based1");
1505                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1506                 reportDefinition.shiftColumnSortDown("1");
1507
1508         }
1509
1510         @Test
1511         public void shiftColumnSortDown1Test() throws Exception {
1512                 PowerMockito.mockStatic(Globals.class);
1513                 PowerMockito.mockStatic(DbUtils.class);
1514                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1515                 DataSet datset = PowerMockito.mock(DataSet.class);
1516                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1517                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1518                 CustomReportType customReportType = mockcustomReportwithDataSource();
1519                 customReportType.setReportType("Hive");
1520                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1521                                 "1", true);
1522                 reportWrapper.setReportDefType("SQL-based1");
1523                 reportWrapper.setReportDefType("SQL-based1");
1524                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1525                 reportDefinition.shiftColumnSortDown("test");
1526
1527         }
1528
1529         @Test
1530         public void generateNewSemaphoreIdTest() throws Exception {
1531                 PowerMockito.mockStatic(Globals.class);
1532                 PowerMockito.mockStatic(DbUtils.class);
1533                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1534                 DataSet datset = PowerMockito.mock(DataSet.class);
1535                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1536                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1537                 CustomReportType customReportType = mockcustomReportwithDataSource1();
1538                 customReportType.setReportType("Hive");
1539                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1540                                 "1", true);
1541                 reportWrapper.setReportDefType("SQL-based1");
1542                 reportWrapper.setReportDefType("SQL-based1");
1543                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1544                 assertEquals(reportDefinition.generateNewSemaphoreId(), "sem2");
1545
1546         }
1547
1548         @Test
1549         public void addSemaphoreTest() throws Exception {
1550                 PowerMockito.mockStatic(Globals.class);
1551                 PowerMockito.mockStatic(DbUtils.class);
1552                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1553                 DataSet datset = PowerMockito.mock(DataSet.class);
1554                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1555                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1556                 CustomReportType customReportType = mockcustomReportwithDataSource1();
1557                 customReportType.setReportType("Hive");
1558                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1559                                 "1", true);
1560                 reportWrapper.setReportDefType("SQL-based1");
1561                 reportWrapper.setReportDefType("SQL-based1");
1562                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1563                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1564                 SemaphoreList semaphoreList = new SemaphoreList();
1565                 SemaphoreType semaphore = new SemaphoreType();
1566                 semaphore.setSemaphoreId("123");
1567                 List<SemaphoreType> semList = new ArrayList<>();
1568                 semList.add(semaphore);
1569                 semaphoreList.semaphore = semList;
1570                 Mockito.when(objectFactory.createSemaphoreList()).thenReturn(semaphoreList);
1571                 Mockito.when(objectFactory.createSemaphoreType()).thenReturn(semaphore);
1572                 assertEquals(reportDefinition.addSemaphore(objectFactory, semaphore).getClass(), SemaphoreType.class);
1573         }
1574
1575         @Test
1576         public void addSemaphore1Test() throws Exception {
1577                 PowerMockito.mockStatic(Globals.class);
1578                 PowerMockito.mockStatic(DbUtils.class);
1579                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1580                 DataSet datset = PowerMockito.mock(DataSet.class);
1581                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1582                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1583                 CustomReportType customReportType = mockcustomReportwithDataSource();
1584                 customReportType.setReportType("Hive");
1585                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1586                                 "1", true);
1587                 reportWrapper.setReportDefType("SQL-based1");
1588                 reportWrapper.setReportDefType("SQL-based1");
1589                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1590                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1591                 SemaphoreList semaphoreList = new SemaphoreList();
1592                 SemaphoreType semaphore = new SemaphoreType();
1593                 semaphore.setSemaphoreId("123");
1594                 semaphore.setSemaphoreName("test1");
1595                 List<SemaphoreType> semList = new ArrayList<>();
1596                 semList.add(semaphore);
1597                 semaphoreList.semaphore = semList;
1598                 Mockito.when(objectFactory.createSemaphoreList()).thenReturn(semaphoreList);
1599                 Mockito.when(objectFactory.createSemaphoreType()).thenReturn(semaphore);
1600                 assertEquals(reportDefinition.addSemaphore(objectFactory, semaphore).getClass(), SemaphoreType.class);
1601         }
1602
1603         @Test(expected = RaptorException.class)
1604         public void addSemaphoreExceptionTest() throws Exception {
1605                 PowerMockito.mockStatic(Globals.class);
1606                 PowerMockito.mockStatic(DbUtils.class);
1607                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1608                 DataSet datset = PowerMockito.mock(DataSet.class);
1609                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1610                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1611                 CustomReportType customReportType = mockcustomReportwithDataSource();
1612                 customReportType.setReportType("Hive");
1613                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1614                                 "1", true);
1615                 reportWrapper.setReportDefType("SQL-based1");
1616                 reportWrapper.setReportDefType("SQL-based1");
1617                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1618                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1619                 SemaphoreList semaphoreList = new SemaphoreList();
1620                 SemaphoreType semaphore = new SemaphoreType();
1621                 semaphore.setSemaphoreId("123");
1622                 semaphore.setSemaphoreName("test1");
1623                 List<SemaphoreType> semList = new ArrayList<>();
1624                 semList.add(semaphore);
1625                 semaphoreList.semaphore = semList;
1626                 Mockito.when(objectFactory.createSemaphoreList()).thenThrow(JAXBException.class);
1627                 Mockito.when(objectFactory.createSemaphoreType()).thenReturn(semaphore);
1628                 reportDefinition.addSemaphore(objectFactory, semaphore);
1629         }
1630
1631         @Test
1632         public void addSemaphoreTypeTest() throws Exception {
1633                 PowerMockito.mockStatic(Globals.class);
1634                 PowerMockito.mockStatic(DbUtils.class);
1635                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1636                 DataSet datset = PowerMockito.mock(DataSet.class);
1637                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1638                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1639                 CustomReportType customReportType = mockcustomReportwithDataSource1();
1640                 customReportType.setReportType("Hive");
1641                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1642                                 "1", true);
1643                 reportWrapper.setReportDefType("SQL-based1");
1644                 reportWrapper.setReportDefType("SQL-based1");
1645                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1646                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1647                 SemaphoreList semaphoreList = new SemaphoreList();
1648                 SemaphoreType semaphore = new SemaphoreType();
1649                 semaphore.setSemaphoreId("123");
1650                 semaphore.setSemaphoreName("sem1");
1651                 List<SemaphoreType> semList = new ArrayList<>();
1652                 semList.add(semaphore);
1653                 semaphoreList.semaphore = semList;
1654                 Mockito.when(objectFactory.createSemaphoreType()).thenReturn(semaphore);
1655                 assertEquals(reportDefinition.addSemaphoreType(objectFactory, "test", "test", "test").getClass(),
1656                                 SemaphoreType.class);
1657         }
1658
1659         @Test
1660         public void addSemaphoreType1Test() throws Exception {
1661                 PowerMockito.mockStatic(Globals.class);
1662                 PowerMockito.mockStatic(DbUtils.class);
1663                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1664                 DataSet datset = PowerMockito.mock(DataSet.class);
1665                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1666                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1667                 CustomReportType customReportType = mockcustomReportwithDataSource();
1668                 customReportType.setReportType("Hive");
1669                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1670                                 "1", true);
1671                 reportWrapper.setReportDefType("SQL-based1");
1672                 reportWrapper.setReportDefType("SQL-based1");
1673                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1674                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1675                 SemaphoreList semaphoreList = new SemaphoreList();
1676                 SemaphoreType semaphore = new SemaphoreType();
1677                 semaphore.setSemaphoreId("123");
1678                 semaphore.setSemaphoreName("sem1");
1679                 List<SemaphoreType> semList = new ArrayList<>();
1680                 semList.add(semaphore);
1681                 semaphoreList.semaphore = semList;
1682                 Mockito.when(objectFactory.createSemaphoreType()).thenReturn(semaphore);
1683                 Mockito.when(objectFactory.createSemaphoreList()).thenReturn(semaphoreList);
1684                 assertEquals(reportDefinition.addSemaphoreType(objectFactory, "test", "test", "").getClass(),
1685                                 SemaphoreType.class);
1686         }
1687
1688         @Test
1689         public void getNextIdForJavaScriptElementTest() throws Exception {
1690                 PowerMockito.mockStatic(Globals.class);
1691                 PowerMockito.mockStatic(DbUtils.class);
1692                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1693                 DataSet datset = PowerMockito.mock(DataSet.class);
1694                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1695                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1696                 CustomReportType customReportType = mockcustomReportwithDataSource();
1697                 customReportType.setReportType("Hive");
1698                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1699                                 "1", true);
1700                 reportWrapper.setReportDefType("SQL-based1");
1701                 reportWrapper.setReportDefType("SQL-based1");
1702                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1703                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1704                 JavascriptList javascriptList = new JavascriptList();
1705
1706                 List<JavascriptItemType> list = new ArrayList<>();
1707                 JavascriptItemType javascriptItemType = new JavascriptItemType();
1708                 javascriptItemType.setFieldId("1");
1709                 list.add(javascriptItemType);
1710                 javascriptList.javascriptItem = list;
1711                 Mockito.when(objectFactory.createJavascriptList()).thenReturn(javascriptList);
1712                 assertEquals(reportDefinition.getNextIdForJavaScriptElement(objectFactory, "1"), "1|1");
1713         }
1714
1715         @Test
1716         public void getNextIdForJavaScriptElement1Test() throws Exception {
1717                 PowerMockito.mockStatic(Globals.class);
1718                 PowerMockito.mockStatic(DbUtils.class);
1719                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1720                 DataSet datset = PowerMockito.mock(DataSet.class);
1721                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1722                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1723                 CustomReportType customReportType = mockcustomReportwithDataSource1();
1724                 JavascriptList javascriptList1 = new JavascriptList();
1725                 customReportType.setJavascriptList(javascriptList1);
1726                 customReportType.setReportType("Hive");
1727                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1728                                 "1", true);
1729                 reportWrapper.setReportDefType("SQL-based1");
1730                 reportWrapper.setReportDefType("SQL-based1");
1731                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1732                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1733                 List<JavascriptItemType> list = new ArrayList<>();
1734                 JavascriptList javascriptList = new JavascriptList();
1735
1736                 JavascriptItemType javascriptItemType = new JavascriptItemType();
1737                 javascriptItemType.setFieldId("1");
1738                 list.add(javascriptItemType);
1739                 javascriptList.javascriptItem = list;
1740                 Mockito.when(objectFactory.createJavascriptList()).thenReturn(javascriptList);
1741                 assertEquals(reportDefinition.getNextIdForJavaScriptElement(objectFactory, "1"), "1|1");
1742         }
1743
1744         @Test(expected = NullPointerException.class)
1745         public void addJavascriptTypeTest() throws Exception {
1746                 PowerMockito.mockStatic(Globals.class);
1747                 PowerMockito.mockStatic(DbUtils.class);
1748                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1749                 DataSet datset = PowerMockito.mock(DataSet.class);
1750                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1751                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1752                 CustomReportType customReportType = mockcustomReportwithDataSource();
1753                 JavascriptList javascriptList1 = new JavascriptList();
1754                 customReportType.setJavascriptList(javascriptList1);
1755                 customReportType.setReportType("Hive");
1756                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1757                                 "1", true);
1758                 reportWrapper.setReportDefType("SQL-based1");
1759                 reportWrapper.setReportDefType("SQL-based1");
1760                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1761                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1762                 assertEquals(reportDefinition.addJavascriptType(objectFactory, "1").getClass(), JavascriptItemType.class);
1763         }
1764
1765         @Test
1766         public void addJavascriptTypeT1est() throws Exception {
1767                 PowerMockito.mockStatic(Globals.class);
1768                 PowerMockito.mockStatic(DbUtils.class);
1769                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1770                 DataSet datset = PowerMockito.mock(DataSet.class);
1771                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1772                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1773                 CustomReportType customReportType = mockcustomReportwithDataSource1();
1774                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1775                                 "1", true);
1776                 reportWrapper.setReportDefType("SQL-based1");
1777                 reportWrapper.setReportDefType("SQL-based1");
1778                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1779                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1780                 assertEquals(reportDefinition.addJavascriptType(objectFactory, "1").getClass(), JavascriptItemType.class);
1781         }
1782
1783         @Test
1784         public void deleteJavascriptTypeTest() throws Exception {
1785                 PowerMockito.mockStatic(Globals.class);
1786                 PowerMockito.mockStatic(DbUtils.class);
1787                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1788                 DataSet datset = PowerMockito.mock(DataSet.class);
1789                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1790                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1791                 CustomReportType customReportType = mockcustomReportwithDataSource();
1792
1793                 JavascriptList javascriptList = new JavascriptList();
1794
1795                 List<JavascriptItemType> list1 = new ArrayList<>();
1796                 JavascriptItemType javascriptItemType = new JavascriptItemType();
1797                 javascriptItemType.setFieldId("1");
1798                 javascriptItemType.setId("23");
1799                 list1.add(javascriptItemType);
1800                 javascriptList.javascriptItem = list1;
1801
1802                 customReportType.setJavascriptList(javascriptList);
1803                 customReportType.setReportType("Hive");
1804                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1805                                 "1", true);
1806                 reportWrapper.setReportDefType("SQL-based1");
1807                 reportWrapper.setReportDefType("SQL-based1");
1808                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1809                 assertTrue(reportDefinition.deleteJavascriptType("23"));
1810         }
1811
1812         @Test
1813         public void deleteJavascriptTypeFalseTest() throws Exception {
1814                 PowerMockito.mockStatic(Globals.class);
1815                 PowerMockito.mockStatic(DbUtils.class);
1816                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1817                 DataSet datset = PowerMockito.mock(DataSet.class);
1818                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1819                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1820                 CustomReportType customReportType = mockcustomReportwithDataSource();
1821
1822                 JavascriptList javascriptList = new JavascriptList();
1823
1824                 List<JavascriptItemType> list1 = new ArrayList<>();
1825                 JavascriptItemType javascriptItemType = new JavascriptItemType();
1826                 javascriptItemType.setFieldId("1");
1827                 javascriptItemType.setId("23");
1828                 list1.add(javascriptItemType);
1829                 javascriptList.javascriptItem = list1;
1830
1831                 customReportType.setJavascriptList(javascriptList);
1832                 customReportType.setReportType("Hive");
1833                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1834                                 "1", true);
1835                 reportWrapper.setReportDefType("SQL-based1");
1836                 reportWrapper.setReportDefType("SQL-based1");
1837                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1838                 assertFalse(reportDefinition.deleteJavascriptType("234"));
1839         }
1840
1841         @Test
1842         public void deleteJavascriptTypeNull() throws Exception {
1843                 PowerMockito.mockStatic(Globals.class);
1844                 PowerMockito.mockStatic(DbUtils.class);
1845                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1846                 DataSet datset = PowerMockito.mock(DataSet.class);
1847                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1848                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1849                 CustomReportType customReportType = mockcustomReportwithDataSource();
1850
1851                 customReportType.setJavascriptList(null);
1852                 customReportType.setReportType("Hive");
1853                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1854                                 "1", true);
1855                 reportWrapper.setReportDefType("SQL-based1");
1856                 reportWrapper.setReportDefType("SQL-based1");
1857                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1858                 assertTrue(reportDefinition.deleteJavascriptType("234"));
1859         }
1860
1861         @Test
1862         public void addEmptyFormatTypeTest() throws Exception {
1863                 ReportDefinition reportDefinition = mockRdf();
1864                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1865                 SemaphoreType semaphore = new SemaphoreType();
1866                 semaphore.setFormatList(mockFormatList());
1867                 FormatType fmt = new FormatType();
1868                 Mockito.when(objectFactory.createFormatType()).thenReturn(fmt);
1869                 reportDefinition.addEmptyFormatType(objectFactory, semaphore);
1870         }
1871
1872         @Test
1873         public void deleteFormatTypeTest() throws Exception {
1874                 ReportDefinition reportDefinition = mockRdf();
1875                 SemaphoreType semaphore = new SemaphoreType();
1876                 semaphore.setFormatList(mockFormatList());
1877                 reportDefinition.deleteFormatType(semaphore, "1");
1878         }
1879
1880         public ReportDefinition mockRdf() throws Exception {
1881                 PowerMockito.mockStatic(Globals.class);
1882                 PowerMockito.mockStatic(DbUtils.class);
1883                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1884                 DataSet datset = PowerMockito.mock(DataSet.class);
1885                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1886                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1887                 CustomReportType customReportType = mockcustomReportwithDataSource1();
1888                 customReportType.setReportType("Hive");
1889                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1890                                 "1", true);
1891                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
1892                 return reportDefinition;
1893         }
1894
1895         @Test
1896         public void addFormFieldTypeTest() throws Exception {
1897                 ReportDefinition reportDefinition = mockRdf();
1898                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1899                 FormFieldType formFieldType = new FormFieldType();
1900                 formFieldType.setColId("1");
1901                 formFieldType.setFieldId("ff1");
1902                 Mockito.when(objectFactory.createFormFieldType()).thenReturn(formFieldType);
1903                 assertEquals(reportDefinition
1904                                 .addFormFieldType(objectFactory, "fieldName", "colId", "fieldType", "validationType", "mandatory",
1905                                                 "defaultValue", "fieldSQL", "comment", null, null, "rangeStartDateSQL", "rangeEndDateSQL")
1906                                 .getClass(), FormFieldType.class);
1907         }
1908
1909         @Test
1910         public void addCustomizedTextForParametersTest() throws Exception {
1911                 ReportDefinition reportDefinition = mockRdf();
1912                 reportDefinition.addCustomizedTextForParameters("test");
1913         }
1914
1915         @Test
1916         public void addFormFieldBlankTest() throws Exception {
1917                 ReportDefinition reportDefinition = mockRdf();
1918                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
1919                 FormFieldType formFieldType = new FormFieldType();
1920                 formFieldType.setColId("1");
1921                 formFieldType.setFieldId("ff1");
1922                 Mockito.when(objectFactory.createFormFieldType()).thenReturn(formFieldType);
1923                 assertEquals(reportDefinition.addFormFieldBlank(objectFactory).getClass(), FormFieldType.class);
1924         }
1925
1926         @Test
1927         public void replaceFormFieldReferencesTest() throws Exception {
1928                 PowerMockito.mockStatic(Utils.class);
1929                 ReportDefinition reportDefinition = mockRdf();
1930                 Mockito.when(Utils.replaceInString(Matchers.anyString(), Matchers.anyString(), Matchers.anyString()))
1931                                 .thenReturn("test");
1932                 reportDefinition.replaceFormFieldReferences("test", "test12");
1933         }
1934
1935         @Test
1936         public void replaceFormFieldReferences1Test() throws Exception {
1937                 PowerMockito.mockStatic(Utils.class);
1938                 ReportDefinition reportDefinition = mockReportDefinition();
1939                 Mockito.when(Utils.replaceInString(Matchers.anyString(), Matchers.anyString(), Matchers.anyString()))
1940                                 .thenReturn("test");
1941                 reportDefinition.replaceFormFieldReferences("test", "test12");
1942         }
1943
1944         @Test
1945         public void replaceFormFieldReferences2Test() throws Exception {
1946                 PowerMockito.mockStatic(Utils.class);
1947                 ReportDefinition reportDefinition = mockReportDefinition();
1948                 Mockito.when(Utils.replaceInString(Matchers.anyString(), Matchers.anyString(), Matchers.anyString()))
1949                                 .thenReturn("test");
1950                 reportDefinition.replaceFormFieldReferences("test", "test");
1951         }
1952
1953         @Test
1954         public void deleteFormFieldTest() throws Exception {
1955                 ReportDefinition reportDefinition = mockRdf();
1956                 reportDefinition.deleteFormField("test");
1957         }
1958
1959         @Test
1960         public void deleteFormField1Test() throws Exception {
1961                 ReportDefinition reportDefinition = mockRdf();
1962                 reportDefinition.deleteFormField("ff1");
1963         }
1964
1965         @Test
1966         public void shiftFormFieldUpTest() throws Exception {
1967                 ReportDefinition reportDefinition = mockRdf();
1968                 reportDefinition.shiftFormFieldUp("1");
1969         }
1970
1971         @Test
1972         public void shiftFormFieldUp1Test() throws Exception {
1973                 PowerMockito.mockStatic(Globals.class);
1974                 PowerMockito.mockStatic(DbUtils.class);
1975                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
1976                 DataSet datset = PowerMockito.mock(DataSet.class);
1977                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
1978                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
1979                 CustomReportType customReportType = mockcustomReportwithDataSource1();
1980                 List<FormFieldType> formfild = new ArrayList<>();
1981                 FormFieldType formFieldType = new FormFieldType();
1982                 formFieldType.setColId("1");
1983                 formFieldType.setFieldId("test");
1984                 formFieldType.setOrderBySeq(4);
1985                 formfild.add(formFieldType);
1986                 FormFieldType formFieldType1 = new FormFieldType();
1987
1988                 formFieldType1.setColId("1");
1989                 formFieldType1.setFieldId("ff1");
1990                 formFieldType1.setOrderBySeq(4);
1991
1992                 formfild.add(formFieldType1);
1993                 FormFieldList formFieldList = new FormFieldList();
1994                 formFieldList.setComment("test");
1995                 formFieldList.formField = formfild;
1996                 customReportType.setFormFieldList(formFieldList);
1997                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
1998                                 "1", true);
1999                 reportWrapper.setReportDefType("SQL-based1");
2000                 reportWrapper.setReportDefType("SQL-based1");
2001                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
2002                 reportDefinition.shiftFormFieldUp("ff1");
2003         }
2004
2005         @Test
2006         public void shiftFormFieldUp3Test() throws Exception {
2007                 ReportDefinition reportDefinition = mockReportDefinition();
2008                 reportDefinition.getCustomReport().setFormFieldList(null);
2009                 reportDefinition.shiftFormFieldUp("1");
2010         }
2011
2012         @Test
2013         public void shiftFormFieldDown4Test() throws Exception {
2014                 ReportDefinition reportDefinition = mockReportDefinition();
2015                 reportDefinition.getCustomReport().setFormFieldList(null);
2016                 reportDefinition.shiftFormFieldDown("1");
2017         }
2018
2019         @Test
2020         public void shiftFormFieldDown1Test() throws Exception {
2021                 PowerMockito.mockStatic(Globals.class);
2022                 PowerMockito.mockStatic(DbUtils.class);
2023                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
2024                 DataSet datset = PowerMockito.mock(DataSet.class);
2025                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
2026                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
2027                 CustomReportType customReportType = mockcustomReportwithDataSource1();
2028                 List<FormFieldType> formfild = new ArrayList<>();
2029                 FormFieldType formFieldType = new FormFieldType();
2030                 formFieldType.setColId("1");
2031                 formFieldType.setFieldId("ff1");
2032                 formFieldType.setOrderBySeq(4);
2033                 formfild.add(formFieldType);
2034                 FormFieldType formFieldType1 = new FormFieldType();
2035
2036                 formFieldType1.setColId("1");
2037                 formFieldType1.setFieldId("test");
2038                 formFieldType1.setOrderBySeq(4);
2039
2040                 formfild.add(formFieldType1);
2041                 FormFieldList formFieldList = new FormFieldList();
2042                 formFieldList.setComment("test");
2043                 formFieldList.formField = formfild;
2044                 customReportType.setFormFieldList(formFieldList);
2045                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
2046                                 "1", true);
2047                 reportWrapper.setReportDefType("SQL-based1");
2048                 reportWrapper.setReportDefType("SQL-based1");
2049                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
2050                 reportDefinition.shiftFormFieldDown("ff1");
2051         }
2052
2053         @Test
2054         public void shiftFormFieldDownTest() throws Exception {
2055                 ReportDefinition reportDefinition = mockRdf();
2056                 reportDefinition.shiftFormFieldDown("1");
2057         }
2058
2059         @Test
2060         public void shiftFormFieldDown2Test() throws Exception {
2061                 ReportDefinition reportDefinition = mockRdf();
2062                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
2063                 FormFieldType formFieldType = new FormFieldType();
2064                 PredefinedValueList predefinedValueList = new PredefinedValueList();
2065                 List<String> predefinedValue = new ArrayList<>();
2066                 predefinedValue.add("test");
2067                 predefinedValueList.predefinedValue = predefinedValue;
2068                 formFieldType.setPredefinedValueList(predefinedValueList);
2069                 formFieldType.setColId("1");
2070                 reportDefinition.addFormFieldPredefinedValue(objectFactory, formFieldType, "test");
2071         }
2072
2073         @Test
2074         public void shiftFormFieldDown3Test() throws Exception {
2075                 ReportDefinition reportDefinition = mockRdf();
2076                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
2077                 FormFieldType formFieldType = new FormFieldType();
2078                 PredefinedValueList predefinedValueList = new PredefinedValueList();
2079                 List<String> predefinedValue = new ArrayList<>();
2080                 predefinedValue.add("test");
2081                 predefinedValueList.predefinedValue = predefinedValue;
2082                 formFieldType.setPredefinedValueList(null);
2083                 formFieldType.setColId("1");
2084                 reportDefinition.addFormFieldPredefinedValue(objectFactory, formFieldType, "");
2085         }
2086
2087         @Test
2088         public void deleteFormFieldPredefinedValueTest() throws Exception {
2089                 ReportDefinition reportDefinition = mockRdf();
2090                 FormFieldType formFieldType = new FormFieldType();
2091                 PredefinedValueList predefinedValueList = new PredefinedValueList();
2092                 List<String> predefinedValue = new ArrayList<>();
2093                 predefinedValue.add("test");
2094                 predefinedValueList.predefinedValue = predefinedValue;
2095                 formFieldType.setPredefinedValueList(predefinedValueList);
2096                 formFieldType.setColId("1");
2097                 reportDefinition.deleteFormFieldPredefinedValue(formFieldType, "test");
2098         }
2099
2100         @Test
2101         public void deleteFormFieldPredefinedValue2Test() throws Exception {
2102                 ReportDefinition reportDefinition = mockRdf();
2103                 FormFieldType formFieldType = new FormFieldType();
2104                 PredefinedValueList predefinedValueList = new PredefinedValueList();
2105                 List<String> predefinedValue = new ArrayList<>();
2106                 predefinedValue.add("test");
2107                 predefinedValueList.predefinedValue = predefinedValue;
2108                 formFieldType.setPredefinedValueList(predefinedValueList);
2109                 formFieldType.setColId("1");
2110                 reportDefinition.deleteFormFieldPredefinedValue(formFieldType, "test1");
2111         }
2112
2113         @Test
2114         public void deleteFormFieldPredefinedValue1Test() throws Exception {
2115                 ReportDefinition reportDefinition = mockRdf();
2116                 FormFieldType formFieldType = new FormFieldType();
2117                 PredefinedValueList predefinedValueList = new PredefinedValueList();
2118                 List<String> predefinedValue = new ArrayList<>();
2119                 predefinedValue.add("test");
2120                 predefinedValueList.predefinedValue = predefinedValue;
2121                 formFieldType.setPredefinedValueList(null);
2122                 formFieldType.setColId("1");
2123                 reportDefinition.deleteFormFieldPredefinedValue(formFieldType, "");
2124         }
2125
2126         @Test(expected = ValidationException.class)
2127         public void parseReportSQLTest() throws Exception {
2128                 ReportDefinition reportDefinition = mockRdf();
2129                 reportDefinition.parseReportSQL("test");
2130         }
2131
2132         @Test(expected = ValidationException.class)
2133         public void parseReportSQL1Test() throws Exception {
2134                 ReportDefinition reportDefinition = mockRdf();
2135                 reportDefinition.parseReportSQL("select * ");
2136         }
2137
2138         @Test(expected = ValidationException.class)
2139         public void parseReportSQL2Test() throws Exception {
2140                 ReportDefinition reportDefinition = mockRdf();
2141                 reportDefinition.getCustomReport().setDbInfo("test");
2142                 reportDefinition.parseReportSQL("select from distinct");
2143         }
2144
2145         @Test
2146         public void parseReportSQL3Test() throws Exception {
2147                 ReportDefinition reportDefinition = mockRdf();
2148                 reportDefinition.getCustomReport().setDbInfo("test");
2149                 reportDefinition.parseReportSQL("select distinct roleID from");
2150         }
2151
2152         @Test
2153         public void addChartAdditionalOptionsTest() throws Exception {
2154                 ReportDefinition reportDefinition = mockRdf();
2155                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
2156                 ChartAdditionalOptions chartOptions = new ChartAdditionalOptions();
2157                 Mockito.when(objectFactory.createChartAdditionalOptions()).thenReturn(chartOptions);
2158                 reportDefinition.addChartAdditionalOptions(objectFactory);
2159         }
2160
2161         @Test
2162         public void addChartDrillOptionsTest() throws Exception {
2163                 ReportDefinition reportDefinition = mockRdf();
2164                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
2165                 ChartDrillOptions chartOptions = new ChartDrillOptions();
2166                 Mockito.when(objectFactory.createChartDrillOptions()).thenReturn(chartOptions);
2167                 reportDefinition.addChartDrillOptions(objectFactory);
2168         }
2169
2170         @Test
2171         public void addDataminingOptionsTest() throws Exception {
2172                 ReportDefinition reportDefinition = mockRdf();
2173                 ObjectFactory objectFactory = PowerMockito.mock(ObjectFactory.class);
2174                 DataminingOptions dataminingOptions = new DataminingOptions();
2175                 Mockito.when(objectFactory.createDataminingOptions()).thenReturn(dataminingOptions);
2176                 reportDefinition.addDataminingOptions(objectFactory);
2177         }
2178 }