package org.dbunit.assertion.comparer.value;
   
   import org.dbunit.DatabaseUnitException;
   import org.dbunit.dataset.ITable;
   import org.dbunit.dataset.datatype.DataType;
   import org.dbunit.dataset.datatype.TypeCastException;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
  /**
   * {@link ValueComparer} implementation that verifies actual value contains
   * expected value by converting to {@link String}s and using
   * {@link String#contains(CharSequence)}. Special case: if both are null, they
   * match.
   *
   * @author Jeff Jensen
   * @since 2.7.0
   */
  public class IsActualContainingExpectedStringValueComparer
          extends ValueComparerTemplateBase
  {
      private final Logger log = LoggerFactory.getLogger(getClass());
  
      @Override
      protected boolean isExpected(final ITable expectedTable,
              final ITable actualTable, final int rowNum, final String columnName,
              final DataType dataType, final Object expectedValue,
              final Object actualValue) throws DatabaseUnitException
      {
          final boolean isExpected;
  
          // handle nulls: prevent NPE and isExpected=true when both null
          if (expectedValue == null && actualValue == null)
          {
              // both are null, so match
              isExpected = true;
          } else if (expectedValue == null || actualValue == null)
          {
              // both aren't null, one is null, so no match
              isExpected = false;
          } else
          {
              // neither are null, so compare
              isExpected = isContaining(expectedValue, actualValue);
          }
  
          return isExpected;
      }
  
      protected boolean isContaining(final Object expectedValue,
              final Object actualValue) throws TypeCastException
      {
          final String expectedValueString = DataType.asString(expectedValue);
          final String actualValueString = DataType.asString(actualValue);
          log.debug("isContaining: expectedValueString={}, actualValueString={}",
                  expectedValueString, actualValueString);
  
          return actualValueString.contains(expectedValueString);
      }
  
      @Override
      protected String getFailPhrase()
      {
          return "not containing";
      }
  }