TestUtil.java

package eu.fbk.knowledgestore.tool;

import java.util.List;
import java.util.Map;
import java.util.Properties;

import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.Maps;

import org.openrdf.model.Value;
import org.openrdf.query.BindingSet;
import org.openrdf.query.impl.MapBindingSet;

import eu.fbk.knowledgestore.data.Data;
import eu.fbk.rdfpro.util.Namespaces;
import eu.fbk.rdfpro.util.Statements;

final class TestUtil {

    // Properties manipulation

    public static <T> T read(final Properties properties, final String name, final Class<T> type) {
        final T value = read(properties, name, type, null);
        if (value == null) {
            throw new IllegalArgumentException("No value for mandatory property '" + name + "'");
        }
        return value;
    }

    public static <T> T read(final Properties properties, final String name, final Class<T> type,
            final T defaultValue) {
        final String value = properties.getProperty(name);
        if (value == null) {
            return defaultValue;
        }
        try {
            return Data.convert(value, type);
        } catch (final Throwable ex) {
            throw new IllegalArgumentException("Invalid value for property '" + name + "': "
                    + value + " (" + ex.getMessage() + ")");
        }
    }

    public static void expand(final Properties targetProperties, final Properties defaultProperties) {
        for (final Map.Entry<Object, Object> entry : defaultProperties.entrySet()) {
            final String name = (String) entry.getKey();
            if (!targetProperties.containsKey(name)) {
                final String value = (String) entry.getValue();
                targetProperties.setProperty(name, value);
            }
        }
    }

    public static Map<String, Properties> split(final Properties properties) {
        final Map<String, Properties> map = Maps.newLinkedHashMap();
        for (final Object key : properties.keySet()) {
            final String keyString = key.toString();
            final int index = keyString.indexOf(".");
            if (index > 0) {
                final String name = keyString.substring(0, index);
                final String property = keyString.substring(index + 1);
                final String value = properties.getProperty(keyString);
                Properties subProperties = map.get(name);
                if (subProperties == null) {
                    subProperties = new Properties();
                    map.put(name, subProperties);
                }
                subProperties.setProperty(property, value);
            }
        }
        return map;
    }

    // TSV and RDF manipulation

    public static BindingSet decode(final List<String> variables, final String line) {
        final String[] tokens = line.split("\t");
        Preconditions.checkArgument(tokens.length == variables.size(), "Wrong number of values ("
                + tokens.length + " found, " + variables.size() + " expected) in line: " + line);
        try {
            final MapBindingSet bindings = new MapBindingSet();
            for (int i = 0; i < tokens.length; ++i) {
                String token = tokens[i];
                if (!Strings.isNullOrEmpty(token)) {
                    final char ch = token.charAt(0);
                    token = ch == '\'' || ch == '"' || ch == '<' || ch == '_' ? token : "\""
                            + token + "\"";
                    final Value value = Statements.parseValue(token, Namespaces.DEFAULT);
                    bindings.addBinding(variables.get(i), value);
                }
            }
            return bindings;
        } catch (final Throwable ex) {
            throw new IllegalArgumentException("Could not parse variable values.\nVariables: "
                    + variables + "\nLine: " + line, ex);
        }
    }

    public static String encode(final List<String> variables, final BindingSet bindings) {
        final StringBuilder builder = new StringBuilder();
        for (int i = 0; i < variables.size(); ++i) {
            if (i > 0) {
                builder.append('\t');
            }
            final Value value = bindings.getValue(variables.get(i));
            builder.append(format(value));
        }
        return builder.toString();
    }

    public static String format(final Iterable<String> variables, final BindingSet bindings,
            final String separator) {
        final StringBuilder builder = new StringBuilder();
        for (final String variable : variables) {
            final Value value = bindings.getValue(variable);
            if (value != null) {
                builder.append(builder.length() == 0 ? "" : separator);
                builder.append(variable);
                builder.append('=');
                builder.append(format(value));
            }
        }
        return builder.toString();
    }

    public static String format(final Value value) {
        // Emit literal without lang / datatype for easier consumption in analysis tools
        if (value instanceof Value) { // was instanceof Resource
            return Statements.formatValue(value, null);
        } else if (value != null) {
            return value.stringValue();
        } else {
            return "";
        }
    }

}