/*******************************************************************************
 * Copyright (c) 2014, 2015 Ericsson
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License 2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *   Bernd Hufmann - Initial API and implementation
 *   Patrick Tasse - Remove getSubField
 *******************************************************************************/
package org.eclipse.tracecompass.tmf.core.tests.trace.text;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.util.List;

import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
import org.eclipse.tracecompass.tmf.core.trace.text.TextTraceEventContent;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.text.SyslogEventType;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.text.SyslogTrace.Field;
import org.junit.Test;

/**
 * Test suite for the {@link TextTraceEventContent} class.
 */
@SuppressWarnings({ "javadoc", "nls" })
public class TextTraceEventContentTest {

    // ------------------------------------------------------------------------
    // Members
    // ------------------------------------------------------------------------

    private static final String[] LABELS = new String[] {
        Field.HOST, Field.LOGGER, Field.FILE, Field.LINE, Field.MESSAGE
    };
    private interface Index {
        int HOST = 0;
        int LOGGER = 1;
        int FILE = 2;
        int LINE = 3;
        int MESSAGE = 4;
    }
    private TextTraceEventContent fEventContent1;
    private TextTraceEventContent fEventContent1Clone;
    private TextTraceEventContent fEventContent2;
    private TextTraceEventContent fEventContent2Clone;

    @SuppressWarnings("null")
    public TextTraceEventContentTest () {
        fEventContent1 = new TextTraceEventContent(LABELS);
        fEventContent1.setValue("CONTENT");
        fEventContent1.setFieldValue(Index.HOST, "HostA");
        fEventContent1.setFieldValue(Index.LOGGER, "LoggerA");
        fEventContent1.setFieldValue(Index.FILE, "SourceFileA");
        fEventContent1.setFieldValue(Index.LINE, "0");
        fEventContent1.setFieldValue(Index.MESSAGE, "MessageA");

        fEventContent1Clone = new TextTraceEventContent(LABELS);
        fEventContent1Clone.setValue("CONTENT");
        fEventContent1Clone.setFieldValue(Index.HOST, "HostA");
        fEventContent1Clone.setFieldValue(Index.LOGGER, "LoggerA");
        fEventContent1Clone.setFieldValue(Index.FILE, "SourceFileA");
        fEventContent1Clone.setFieldValue(Index.LINE, "0");
        fEventContent1Clone.setFieldValue(Index.MESSAGE, "MessageA");

        fEventContent2 = new TextTraceEventContent(LABELS.length);
        fEventContent2.setFieldValue(LABELS[0], "HostB");
        fEventContent2.setFieldValue(LABELS[1], "LoggerB");
        fEventContent2.setFieldValue(LABELS[2], "SourceFileB");
        fEventContent2.setFieldValue(LABELS[3], "2");
        StringBuffer buffer = new StringBuffer();
        buffer.append("Message B");
        fEventContent2.setFieldValue(LABELS[4], buffer);

        fEventContent2Clone = new TextTraceEventContent(LABELS);
        fEventContent2Clone.setFieldValue(LABELS[0], "HostB");
        fEventContent2Clone.setFieldValue(LABELS[1], "LoggerB");
        fEventContent2Clone.setFieldValue(LABELS[2], "SourceFileB");
        fEventContent2Clone.setFieldValue(LABELS[3], "2");
        buffer = new StringBuffer();
        buffer.append("Message B");
        fEventContent2Clone.setFieldValue(LABELS[4], buffer);
    }

    public void testConstructorConstructor() {
        assertEquals("getField:HOST", "HostA", fEventContent1.getFieldValue(Index.HOST));
        assertEquals("getField:LOGGER", "LoggerA", fEventContent1.getFieldValue(Index.LOGGER));
        assertEquals("getField:FILE", "SourceFileA", fEventContent1.getFieldValue(Index.FILE));
        assertEquals("getField:LINE", "0", fEventContent1.getFieldValue(Index.LINE));
        assertEquals("getField:MESSAGE", "MessageA", fEventContent1.getFieldValue(Index.MESSAGE).toString());
    }

    // ------------------------------------------------------------------------
    // Event Type
    // ------------------------------------------------------------------------

    @Test
    public void testEventTypeInstance() {
        SyslogEventType eventType = SyslogEventType.INSTANCE;
        assertEquals("getTypeId", "Syslog", eventType.getName());
        assertNotNull ("instance", eventType);
        assertEquals ("getFieldNames", 0, eventType.getFieldNames().size());
    }

    // ------------------------------------------------------------------------
    // equals
    // ------------------------------------------------------------------------

    @Test
    public void testEquals() {
        assertEquals("equals", fEventContent1, fEventContent1);
        assertEquals("equals", fEventContent2, fEventContent2);

        assertTrue("equals", !fEventContent1.equals(fEventContent2));
        assertTrue("equals", !fEventContent2.equals(fEventContent1));

        assertEquals("equals", fEventContent1, fEventContent1Clone);
        assertEquals("equals", fEventContent2, fEventContent2Clone);
    }

    @Test
    public void testEqualsNull() {
        assertTrue("equals", !fEventContent1.equals(null));
        assertTrue("equals", !fEventContent2.equals(null));
    }

    // ------------------------------------------------------------------------
    // hashCode
    // ------------------------------------------------------------------------

    @Test
    public void testHashCode() {

        assertEquals("hashCode", fEventContent1.hashCode(), fEventContent1Clone.hashCode());
        assertEquals("hashCode", fEventContent2.hashCode(), fEventContent2Clone.hashCode());

        assertNotEquals("hashCode", fEventContent1.hashCode(), fEventContent2.hashCode());
        assertNotEquals("hashCode", fEventContent2.hashCode(), fEventContent1.hashCode());
    }

    // ------------------------------------------------------------------------
    // Event Content
    // ------------------------------------------------------------------------

    @Test
    public void testGetFieldValueWithIndex() {
        assertEquals("getFieldValue:HOST", "HostA", fEventContent1.getFieldValue(Index.HOST));
        assertEquals("getFieldValue:LOGGER", "LoggerA", fEventContent1.getFieldValue(Index.LOGGER));
        assertEquals("getFieldValue:FILE", "SourceFileA", fEventContent1.getFieldValue(Index.FILE));
        assertEquals("getFieldValue:LINE", "0", fEventContent1.getFieldValue(Index.LINE));
        assertEquals("getFieldValue:MESSAGE", "MessageA", fEventContent1.getFieldValue(Index.MESSAGE));
        assertNull(fEventContent1.getFieldValue(5));
    }

    @Test
    public void testGetFieldValueWithName() {
        assertEquals("getFieldValue:HOST", "HostA", fEventContent1.getFieldValue("Host"));
        assertEquals("getFieldValue:LOGGER", "LoggerA", fEventContent1.getFieldValue("Logger"));
        assertEquals("getFieldValue:FILE", "SourceFileA", fEventContent1.getFieldValue("File"));
        assertEquals("getFieldValue:LINE", "0", fEventContent1.getFieldValue("Line"));
        assertEquals("getFieldValue:MESSAGE", "MessageA", fEventContent1.getFieldValue("Message"));
        assertNull(fEventContent1.getFieldValue("BlaBla"));
    }

    @Test
    public void testGetFieldNameWithIndex() {

        assertEquals("getFieldName:HOST", LABELS[0], fEventContent1.getFieldName(Index.HOST));
        assertEquals("getFieldName:LOGGER", LABELS[1], fEventContent1.getFieldName(Index.LOGGER));
        assertEquals("getFieldName:FILE", LABELS[2], fEventContent1.getFieldName(Index.FILE));
        assertEquals("getFieldName:LINE", LABELS[3], fEventContent1.getFieldName(Index.LINE));
        assertEquals("getFieldName:MESSAGE", LABELS[4], fEventContent1.getFieldName(Index.MESSAGE));
        assertNull(fEventContent1.getFieldValue(5));
    }

    @Test
    public void testGetFields() {
        List<TextTraceEventContent> fields = fEventContent1.getFields();
        assertEquals(5, fields.size());
        assertEquals("getFields:HOST", LABELS[0], fields.get(Index.HOST).getName());
        assertEquals("getFields:HOST", "HostA", fields.get(Index.HOST).getValue());
        assertEquals("getFields:LOGGER", LABELS[1], fields.get(Index.LOGGER).getName());
        assertEquals("getFields:LOGGER", "LoggerA", fields.get(Index.LOGGER).getValue());
        assertEquals("getFields:FILE", LABELS[2], fields.get(Index.FILE).getName());
        assertEquals("getFields:FILE", "SourceFileA", fields.get(Index.FILE).getValue());
        assertEquals("getFields:LINE", LABELS[3], fields.get(Index.LINE).getName());
        assertEquals("getFields:LINE", "0", fields.get(Index.LINE).getValue());
        assertEquals("getFields:MESSAGE", LABELS[4], fields.get(Index.MESSAGE).getName());
        assertEquals("getFields:MESSAGE", "MessageA", fields.get(Index.MESSAGE).getValue());
    }

    @Test
    public void testGetFieldWithName() {
        ITmfEventField field = fEventContent1.getField(LABELS[0]);
        assertEquals("getFieldName:HOST", LABELS[0], field.getName());
        assertEquals("getFieldName:HOST", "HostA", field.getValue());

        field = fEventContent1.getField(LABELS[1]);
        assertEquals("getFieldName:LOGGER", LABELS[1], field.getName());
        assertEquals("getFieldName:LOGGER", "LoggerA", field.getValue());

        field = fEventContent1.getField(LABELS[2]);
        assertEquals("getFieldName:FILE", LABELS[2], field.getName());
        assertEquals("getFieldName:FILE", "SourceFileA", field.getValue());

        field = fEventContent1.getField(LABELS[3]);
        assertEquals("getFieldName:LINE", LABELS[3], field.getName());
        assertEquals("getFieldName:LINE", "0", field.getValue());

        field = fEventContent1.getField(LABELS[4]);
        assertEquals("getFieldName:Message", LABELS[4], field.getName());
        assertEquals("getFieldName:Message", "MessageA", field.getValue());

        field = fEventContent1.getField("BlaBla");
        assertNull(field);
    }

    @Test
    public void testGetFieldWithPath() {
        String[] path = { "Host" };

        ITmfEventField field = fEventContent1.getField(path);
        assertEquals("getFieldPath:HOST", LABELS[0], field.getName());
        assertEquals("getFieldPath:HOST", "HostA", field.getValue());

        String[] path2 = { "Host", "subField" };
        field = fEventContent1.getField(path2);
        assertNull(field);
    }

    @Test
    public void testGetFormattedValue() {
        assertEquals("CONTENT", fEventContent1.getFormattedValue());
    }

    @Test
    public void testToString() {
        assertEquals("Host=HostA, Logger=LoggerA, File=SourceFileA, Line=0, Message=MessageA", fEventContent1.toString());
    }

    @Test
    public void testGetFieldNames() {
        String[] labels = {"Host", "Logger", "File", "Line", "Message"};
        List<String> names = fEventContent1.getFieldNames();
        assertArrayEquals(labels, names.toArray(new String[names.size()]));
    }

}