📄 replacementtabletest.java

📁 采用 Java 编写的数据库系统单元测试程序。
💻 JAVA
字号:
/*
 *
 * The DbUnit Database Testing Framework
 * Copyright (C)2002-2004, DbUnit.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
package org.dbunit.dataset;

import org.dbunit.Assertion;
import org.dbunit.dataset.datatype.DataType;
import org.dbunit.dataset.xml.FlatXmlDataSet;

import java.io.File;
import java.math.BigDecimal;
import java.sql.Date;

/**
 *
 * @author Manuel Laflamme
 * @since Mar 17, 2003
 * @version $Revision: 612 $
 */
public class ReplacementTableTest extends AbstractTableTest
{
    public ReplacementTableTest(String s)
    {
        super(s);
    }

    protected ITable createTable() throws Exception
    {
        return createDataSet().getTable("TEST_TABLE");
    }

    private IDataSet createDataSet() throws Exception
    {
        return new ReplacementDataSet(
                new FlatXmlDataSet(new File("src/xml/flatXmlTableTest.xml")));
    }

    public void testGetMissingValue() throws Exception
    {
        // TODO test something usefull
    }

    public void testObjectReplacement() throws Exception
    {
        String tableName = "TABLE_NAME";
        BigDecimal trueObject = new BigDecimal((double)1);
        BigDecimal falseObject = new BigDecimal((double)0);
        Date now = new Date(System.currentTimeMillis());

        Column[] columns = new Column[] {
            new Column("BOOLEAN_TRUE", DataType.BOOLEAN),
            new Column("BOOLEAN_FALSE", DataType.BOOLEAN),
            new Column("STRING_TRUE", DataType.CHAR),
            new Column("STRING_FALSE", DataType.CHAR),
            new Column("STRING_VALUE", DataType.CHAR),
            new Column("DATE_VALUE", DataType.DATE),
            new Column("NULL_TO_STRING_VALUE", DataType.CHAR),
            new Column("STRING_TO_NULL_VALUE", DataType.CHAR),
        };

        // Setup actual table
        Object[] actualRow = new Object[] {
            Boolean.TRUE,
            Boolean.FALSE,
            Boolean.TRUE.toString(),
            Boolean.FALSE.toString(),
            "value",
            "now",
            null,
            "null",
        };

        DefaultTable originalTable = new DefaultTable(tableName, columns);
        originalTable.addRow(actualRow);
        ReplacementTable actualTable = new ReplacementTable(originalTable);
        actualTable.addReplacementObject(Boolean.TRUE, trueObject);
        actualTable.addReplacementObject(Boolean.FALSE, falseObject);
        actualTable.addReplacementObject("now", now);
        actualTable.addReplacementObject("null", null);
        actualTable.addReplacementObject(null, "nullreplacement");

        // Setup expected table
        Object[] expectedRow = new Object[] {
            trueObject,
            falseObject,
            Boolean.TRUE.toString(),
            Boolean.FALSE.toString(),
            "value",
            now,
            "nullreplacement",
            null,
        };

        DefaultTable expectedTable = new DefaultTable(tableName, columns);
        expectedTable.addRow(expectedRow);

        Assertion.assertEquals(expectedTable, actualTable);
    }

    public void testSubstringReplacement() throws Exception
    {
        String tableName = "TABLE_NAME";

        Column[] columns = new Column[] {
            new Column("ONLY_SUBSTRING", DataType.CHAR),
            new Column("START_SUBSTRING", DataType.CHAR),
            new Column("MIDDLE_SUBSTRING", DataType.CHAR),
            new Column("END_SUBSTRING", DataType.CHAR),
            new Column("MULTIPLE_SUBSTRING", DataType.CHAR),
            new Column("NO_SUBSTRING", DataType.CHAR),
            new Column("NOT_A_STRING", DataType.NUMERIC),
            new Column("NULL_VALUE", DataType.CHAR),
        };

        // Setup actual table
        Object[] actualRow = new Object[] {
            "substring",
            "substring_",
            "_substring_",
            "_substring",
            "substringsubstring substring",
            "this is a string",
            new Long(0),
            null,
        };

        DefaultTable originalTable = new DefaultTable(tableName, columns);
        originalTable.addRow(actualRow);
        ReplacementTable actualTable = new ReplacementTable(originalTable);
        actualTable.addReplacementSubstring("substring", "replacement");

        // Setup expected table
        Object[] expectedRow = new Object[] {
            "replacement",
            "replacement_",
            "_replacement_",
            "_replacement",
            "replacementreplacement replacement",
            "this is a string",
            new Long(0),
            null,
        };

        DefaultTable expectedTable = new DefaultTable(tableName, columns);
        expectedTable.addRow(expectedRow);

        Assertion.assertEquals(expectedTable, actualTable);
    }

    public void testSubstringReplacementWithMultipleReplacementStrings() throws Exception
    {
        String tableName = "TABLE_NAME";

        Column[] columns = new Column[] {
            new Column("ONLY_SUBSTRING", DataType.CHAR),
            new Column("START_SUBSTRING", DataType.CHAR),
            new Column("MIDDLE_SUBSTRING", DataType.CHAR),
            new Column("END_SUBSTRING", DataType.CHAR),
            new Column("MULTIPLE_SUBSTRING", DataType.CHAR),
            new Column("NO_SUBSTRING", DataType.CHAR),
            new Column("NOT_A_STRING", DataType.NUMERIC),
            new Column("NULL_VALUE", DataType.CHAR),
        };

        // Setup actual table
        Object[] actualRow = new Object[] {
            "substring",
            "substring_",
            "_substring_",
            "_substring",
            "substringsubstring substring",
            "this is a string",
            new Long(0),
            null,
        };

        DefaultTable originalTable = new DefaultTable(tableName, columns);
        originalTable.addRow(actualRow);
        ReplacementTable actualTable = new ReplacementTable(originalTable);
        actualTable.addReplacementSubstring("aaaa", "value");
        actualTable.addReplacementSubstring("substring", "replacement");
        actualTable.addReplacementSubstring("zzzz", "value");

        // Setup expected table
        Object[] expectedRow = new Object[] {
            "replacement",
            "replacement_",
            "_replacement_",
            "_replacement",
            "replacementreplacement replacement",
            "this is a string",
            new Long(0),
            null,
        };

        DefaultTable expectedTable = new DefaultTable(tableName, columns);
        expectedTable.addRow(expectedRow);

        Assertion.assertEquals(expectedTable, actualTable);
    }
    
    public void testDelimitedSubstringReplacement() throws Exception
    {
        String tableName = "TABLE_NAME";

        Column[] columns = new Column[] {
            new Column("ONLY_SUBSTRING", DataType.CHAR),
            new Column("START_SUBSTRING", DataType.CHAR),
            new Column("MIDDLE_SUBSTRING", DataType.CHAR),
            new Column("END_SUBSTRING", DataType.CHAR),
            new Column("MULTIPLE_SUBSTRING", DataType.CHAR),
            new Column("NO_SUBSTRING", DataType.CHAR),
            new Column("NOT_A_STRING", DataType.NUMERIC),
            new Column("NULL_VALUE", DataType.CHAR),
            new Column("ONLY_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("START_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("MIDDLE_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("END_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("MULTIPLE_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("BAD_DELIMITED_SUBSTRING1", DataType.CHAR),
            new Column("BAD_DELIMITED_SUBSTRING2", DataType.CHAR),
            new Column("BAD_DELIMITED_SUBSTRING3", DataType.CHAR),
//            new Column("BAD_DELIMITED_SUBSTRING4", DataType.CHAR),
            new Column("BAD_DELIMITED_SUBSTRING5", DataType.CHAR),
            new Column("BAD_DELIMITED_SUBSTRING6", DataType.CHAR),
            new Column("BAD_SUBSTRING1", DataType.CHAR),
            new Column("BAD_SUBSTRING2", DataType.CHAR),
        };

        // Setup actual table
        Object[] actualRow = new Object[] {
            "${substring}",
            "${substring}_",
            "_${substring}_",
            "_${substring}",
            "${substring}${substring} ${substring}",
            "this is a string",
            new Long(0),
            null,
            "substring",
            "substring_",
            "_substring_",
            "_substring",
            "substringsubstring substring",
            "_${substring_",
            "_$substring}_",
            "_substring}_",
            "}",
            "${",
//            "${substring${substring} ${substring}",  - Should we support this???
            "${substringsubstring}${}${}${substring}${}_",
            "${}",
        };

        DefaultTable originalTable = new DefaultTable(tableName, columns);
        originalTable.addRow(actualRow);
        ReplacementTable actualTable = new ReplacementTable(originalTable);
        actualTable.addReplacementSubstring("substring", "replacement");
        actualTable.setSubstringDelimiters("${", "}");

        // Setup expected table
        Object[] expectedRow = new Object[] {
            "replacement",
            "replacement_",
            "_replacement_",
            "_replacement",
            "replacementreplacement replacement",
            "this is a string",
            new Long(0),
            null,
            "substring",
            "substring_",
            "_substring_",
            "_substring",
            "substringsubstring substring",
            "_${substring_",
            "_$substring}_",
            "_substring}_",
            "}",
            "${",
//            "${substringreplacement replacement",
            "${substringsubstring}${}${}replacement${}_",
            "${}",
        };

        DefaultTable expectedTable = new DefaultTable(tableName, columns);
        expectedTable.addRow(expectedRow);

        Assertion.assertEquals(expectedTable, actualTable);
    }

    public void testDelimitedSubstringReplacementWithIdenticalDelimiters() throws Exception
    {
        String tableName = "TABLE_NAME";

        Column[] columns = new Column[] {
            new Column("ONLY_SUBSTRING", DataType.CHAR),
            new Column("START_SUBSTRING", DataType.CHAR),
            new Column("MIDDLE_SUBSTRING", DataType.CHAR),
            new Column("END_SUBSTRING", DataType.CHAR),
            new Column("MULTIPLE_SUBSTRING", DataType.CHAR),
            new Column("NO_SUBSTRING", DataType.CHAR),
            new Column("NOT_A_STRING", DataType.NUMERIC),
            new Column("NULL_VALUE", DataType.CHAR),
            new Column("ONLY_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("START_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("MIDDLE_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("END_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("MULTIPLE_NONDELIMITED_SUBSTRING", DataType.CHAR),
            new Column("BAD_DELIMITED_SUBSTRING1", DataType.CHAR),
            new Column("BAD_DELIMITED_SUBSTRING2", DataType.CHAR),
//            new Column("BAD_DELIMITED_SUBSTRING4", DataType.CHAR),
            new Column("BAD_DELIMITED_SUBSTRING5", DataType.CHAR),
            new Column("BAD_SUBSTRING1", DataType.CHAR),
            new Column("BAD_SUBSTRING2", DataType.CHAR),
        };

        // Setup actual table
        Object[] actualRow = new Object[] {
            "!substring!",
            "!substring!_",
            "_!substring!_",
            "_!substring!",
            "!substring!!substring! !substring!",
            "this is a string",
            new Long(0),
            null,
            "substring",
            "substring_",
            "_substring_",
            "_substring",
            "substringsubstring substring",
            "_!substring_",
            "_substring!_",
            "!",
//            "!substring!substring! !substring!",  - Should we support this???
            "!substringsubstring!!!!!!substring!!!_",
            "!!",
        };

        DefaultTable originalTable = new DefaultTable(tableName, columns);
        originalTable.addRow(actualRow);
        ReplacementTable actualTable = new ReplacementTable(originalTable);
        actualTable.addReplacementSubstring("substring", "replacement");
        actualTable.setSubstringDelimiters("!", "!");

        // Setup expected table
        Object[] expectedRow = new Object[] {
            "replacement",
            "replacement_",
            "_replacement_",
            "_replacement",
            "replacementreplacement replacement",
            "this is a string",
            new Long(0),
            null,
            "substring",
            "substring_",
            "_substring_",
            "_substring",
            "substringsubstring substring",
            "_!substring_",
            "_substring!_",
            "!",
//            "!substringreplacement replacement",
            "!substringsubstring!!!!!replacement!!_",
            "!!",
        };

        DefaultTable expectedTable = new DefaultTable(tableName, columns);
        expectedTable.addRow(expectedRow);

        Assertion.assertEquals(expectedTable, actualTable);
    }

    public void testAddNullReplacementSubstring() throws Exception
    {
        ReplacementTable replacementTable =
                new ReplacementTable(new DefaultTable("TABLE"));
        try
        {
            replacementTable.addReplacementSubstring(null, "replacement");
            fail("Should not be here!");
        }
        catch (NullPointerException e)
        {
        }

        try
        {
            replacementTable.addReplacementSubstring("substring", null);
            fail("Should not be here!");
        }
        catch (NullPointerException e)
        {
        }
    }

}
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -