AbstractRegexFilterTest.java

/*
 * This file is part of ALOE.
 *
 * ALOE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * ALOE 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 General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with ALOE.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Copyright (c) 2012 SCCL, University of Washington (http://depts.washington.edu/sccl)
 */
package etc.aloe.filters;

import etc.aloe.filters.AbstractRegexFilter.NamedRegex;
import java.util.ArrayList;
import java.util.List;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import weka.core.Attribute;
import weka.core.DenseInstance;
import weka.core.Instance;
import weka.core.Instances;

/**
 *
 * @author Michael Brooks <mjbrooks@uw.edu>
 */
public class AbstractRegexFilterTest {

    public AbstractRegexFilterTest() {
    }

    @BeforeClass
    public static void setUpClass() {
    }

    @AfterClass
    public static void tearDownClass() {
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    /**
     * Test of getStringAttributeName method, of class AbstractRegexFilter.
     */
    @Test
    public void testGetStringAttributeName() {
        System.out.println("getStringAttributeName");
        AbstractRegexFilter instance = new AbstractRegexFilterImpl();
        String expResult = "my name";
        instance.setStringAttributeName(expResult);
        String result = instance.getStringAttributeName();
        assertEquals(expResult, result);
    }

    /**
     * Test of determineOutputFormat method, of class AbstractRegexFilter.
     */
    @Test
    public void testDetermineOutputFormat() throws Exception {
        System.out.println("determineOutputFormat");

        AbstractRegexFilter instance = new AbstractRegexFilterImpl();
        instance.setStringAttributeName("string_attr");

        ArrayList<Attribute> attrs = new ArrayList<Attribute>();
        attrs.add(new Attribute("string_attr", (List<String>) null));
        attrs.add(new Attribute("another_attr"));
        Instances inputFormat = new Instances("data", attrs, 0);

        instance.setCountRegexLengths(false);
        Instances output = instance.determineOutputFormat(inputFormat);
        assertEquals(3, output.numAttributes());
        assertEquals("regex", output.attribute(2).name());

        instance.setCountRegexLengths(true);
        output = instance.determineOutputFormat(inputFormat);
        assertEquals(4, output.numAttributes());
        assertEquals("regex", output.attribute(2).name());
        assertEquals("regex_L", output.attribute(3).name());

    }

    /**
     * Test of process method, of class AbstractRegexFilter.
     */
    @Test
    public void testProcess() throws Exception {
        System.out.println("process");
        AbstractRegexFilter filter = new AbstractRegexFilterImpl();
        filter.setStringAttributeName("string_attr");

        ArrayList<Attribute> attrs = new ArrayList<Attribute>();
        attrs.add(new Attribute("string_attr", (List<String>) null));
        attrs.add(new Attribute("another_attr"));

        Instances inputFormat = new Instances("data", attrs, 0);
        Attribute stringAttr = inputFormat.attribute("string_attr");
        Attribute anotherAttr = inputFormat.attribute("another_attr");

        List<Instance> instances = new ArrayList<Instance>();
        Instance a = new DenseInstance(2);
        a.setValue(stringAttr, "i have one");
        a.setValue(anotherAttr, 1);
        instances.add(a);

        Instance b = new DenseInstance(2);
        b.setValue(stringAttr, "aaaaa");
        b.setValue(anotherAttr, 5);
        instances.add(b);

        Instance c = new DenseInstance(2);
        c.setValue(stringAttr, "nothing here");
        c.setValue(anotherAttr, 0);
        instances.add(c);

        inputFormat.addAll(instances);
        filter.setInputFormat(inputFormat);
        Instances output = filter.getOutputFormat();

        for (int i = 0; i < instances.size(); i++) {
            Instance original = inputFormat.get(i);
            Instance filtered = filter.process(original);
            filtered.setDataset(output);

            assertEquals(original.stringValue(0), filtered.stringValue(0));
            assertEquals(original.value(1), filtered.value(1), 0);
            assertEquals(original.value(1), filtered.value(2), 0);
        }
    }

    /**
     * Test of globalInfo method, of class AbstractRegexFilter.
     */
    @Test
    public void testGlobalInfo() {
        System.out.println("globalInfo");
        AbstractRegexFilter instance = new AbstractRegexFilterImpl();
        String result = instance.globalInfo();
        assertTrue(result.length() > 0);
    }

    /**
     * Test of toRegex method, of class AbstractRegexFilter.
     */
    @Test
    public void testToRegex_StringArr() {
        System.out.println("toRegex");
        String[] fragments = new String[]{
            "abc",
            "def",
            "ghi"
        };
        AbstractRegexFilter instance = new AbstractRegexFilterImpl();
        String expResult = "\\Qabc\\E|\\Qdef\\E|\\Qghi\\E";
        String result = instance.toRegex(fragments);
        assertEquals(expResult, result);

        fragments = new String[]{
            "abc(d)",
            "e[f*]+"
        };
        expResult = "\\Qabc(d)\\E|\\Qe[f*]+\\E";
        result = instance.toRegex(fragments);
        assertEquals(expResult, result);
    }

    /**
     * Test of toRegex method, of class AbstractRegexFilter.
     */
    @Test
    public void testToRegex_StringArr_boolean() {
        System.out.println("toRegex");
        String[] fragments = new String[]{
            "abc",
            "def",
            "ghi"
        };
        AbstractRegexFilter instance = new AbstractRegexFilterImpl();
        String expResult = "abc|def|ghi";
        String result = instance.toRegex(fragments, false);
        assertEquals(expResult, result);

        fragments = new String[]{
            "abc(d)",
            "e[f*]+"
        };
        expResult = "abc(d)|e[f*]+";
        result = instance.toRegex(fragments, false);
        assertEquals(expResult, result);
    }

    public class AbstractRegexFilterImpl extends AbstractRegexFilter {

        @Override
        public NamedRegex[] getRegexFeatures() {
            return new NamedRegex[]{
                        new NamedRegex("regex", "a")
                    };
        }
    }
}