Package org.dbunit.dataset.datatype

Examples of org.dbunit.dataset.datatype.DataType

178
179
180
181
182
183
184
185
186
187
188
        int columnType = rsMetaData.getColumnType(rsIndex);
        String columnTypeName = rsMetaData.getColumnTypeName(rsIndex);
        String columnName = rsMetaData.getColumnName(rsIndex);
        int isNullable = rsMetaData.isNullable(rsIndex);

        DataType dataType = dataTypeFactory.createDataType(
                    columnType, columnTypeName, tableName, columnName);

        Column column = new Column(
                columnName,
                dataType,
View Full Code Here
59
60
61
62
63
64
65
66
67
68
69
      return DATABASE_PRODUCTS;
    }


    public DataType createDataType(int sqlType, String sqlTypeName) throws DataTypeException {
        DataType retValue = super.createDataType(sqlType, sqlTypeName);

        if (logger.isDebugEnabled()) {
            logger.debug("createDataType(sqlType={}, sqlTypeName={}) - start", String.valueOf(sqlType), sqlTypeName);
        }
View Full Code Here
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
            // iterate over all columns of the current row
            for (int j = 0; j < comparisonCols.length; j++) {
                ComparisonColumn compareColumn = comparisonCols[j];

                String columnName = compareColumn.getColumnName();
                DataType dataType = compareColumn.getDataType();

                Object expectedValue = expectedTable.getValue(i, columnName);
                Object actualValue = actualTable.getValue(i, columnName);

                // Compare the values
                if (skipCompare(columnName, expectedValue, actualValue)) {
                    if (logger.isTraceEnabled()) {
                        logger.trace( "ignoring comparison " + expectedValue + "=" +
                                actualValue + " on column " + columnName);                       
                    }
                    continue;
                }

                if (dataType.compare(expectedValue, actualValue) != 0) {

                    Difference diff = new Difference(
                            expectedTable, actualTable,
                            i, columnName,
                            expectedValue, actualValue);
View Full Code Here
658
659
660
661
662
663
664
665
666
667
668
669
                logger.debug(
                                "getComparisonDataType(tableName={}, expectedColumn={}, actualColumn={}, failureHandler={}) - start",
                        new Object[] { tableName, expectedColumn, actualColumn,
                                failureHandler });

            DataType expectedDataType = expectedColumn.getDataType();
            DataType actualDataType = actualColumn.getDataType();

            // The two columns have different data type
            if (!expectedDataType.getClass().isInstance(actualDataType)) {
                // Expected column data type is unknown, use actual column data type
                if (expectedDataType instanceof UnknownDataType) {
View Full Code Here
342
343
344
345
346
347
348
349
350
351
352
353
            Column[] columns = _operationData.getColumns();
            for (int i = 0; i < columns.length; i++)
            {
                Object value = table.getValue(row, columns[i].getColumnName());
                DataType dataType = columns[i].getDataType();
                dataType.setSqlValue(value, i + 1, _countStatement);
            }

            ResultSet resultSet = _countStatement.executeQuery();
            try
            {
View Full Code Here
367
368
369
370
371
372
373
374
375
                logger.debug(
                        "compare(column={}, value1={}, value2={}) - start",
                        new Object[] {column, value1, value2});
            }

            DataType dataType = column.getDataType();
            int result = dataType.compare(value1, value2);
            return result;
        }
View Full Code Here
409
410
411
412
413
414
415
416
417
418
419
                        "Table=" + tableName + ", Column=" +columnName, e);
            // Ignore this one here
        }
       
        // Convert SQL type to DataType
        DataType dataType =
                dataTypeFactory.createDataType(sqlType, sqlTypeName, tableName, columnName);
        if (dataType != DataType.UNKNOWN)
        {
            Column column = new Column(columnName, dataType,
                    sqlTypeName, Column.nullableValue(nullable), columnDefaultValue, remarks,
View Full Code Here
59
60
61
62
63
64
65
66
67
68
69
        Column[] columns = new Column[metaData.getColumnCount()];
        for (int i = 0; i < columns.length; i++)
        {
            int columnType = metaData.getColumnType(i + 1);
            String columnTypeName = metaData.getColumnTypeName(i + 1);
            DataType dataType = dataTypeFactory.createDataType(
                    columnType, columnTypeName);
            columns[i] = new Column(
                    metaData.getColumnName(i + 1),
                    dataType,
                    columnTypeName,
View Full Code Here
202
203
204
205
206
207
208
209
210
211
212
                        String sqlTypeName = resultSet.getString(6);
//                        int columnSize = resultSet.getInt(7);
                        int nullable = resultSet.getInt(11);

                        // Convert SQL type to DataType
                        DataType dataType =
                                dataTypeFactory.createDataType(sqlType, sqlTypeName);
                        if (dataType != DataType.UNKNOWN)
                        {
                            Column column = new Column(columnName, dataType,
                                    sqlTypeName, Column.nullableValue(nullable));
View Full Code Here
138
139
140
141
142
143
144
145
146
147
148
149
150
                String columnName = expectedColumn.getColumnName();
                Object expectedValue = expectedTable.getValue(i, columnName);
                Object actualValue = actualTable.getValue(i, columnName);

                DataType dataType = getComparisonDataType(
                        expectedTableName, expectedColumn, actualColumn);
                if (dataType.compare(expectedValue, actualValue) != 0)
                {
                    Assert.fail("value (table=" + expectedTableName + ", " +
                            "row=" + i + ", col=" + columnName + "): expected:<" +
                            expectedValue + "> but was:<" + actualValue + ">");
                }
View Full Code Here
TOP

Related Classes of org.dbunit.dataset.datatype.DataType

  • org.dbunit.Assertion
  • org.dbunit.assertion.DbUnitAssert
  • org.dbunit.assertion.DbUnitAssert$ComparisonColumn
  • org.dbunit.database.DatabaseTableMetaData
  • org.dbunit.database.ResultSetTableMetaData
  • org.dbunit.dataset.SortedTable$RowComparator
  • org.dbunit.ext.mckoi.MckoiDataTypeFactory
  • org.dbunit.operation.RefreshOperation$RowExistOperation
  • org.dbunit.util.SQLHelper
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.