Rename slf4j ref impl, add constants

Change-Id: Ib3f24c3aa4974ac8c87fa969613192e884674f00
Issue-ID: LOG-115
Signed-off-by: Luke Parker <lparker@amdocs.com>

5 files changed, 725 insertions, 0 deletions

diff --git a/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterOutputTest.java b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterOutputTest.java
new file mode 100644
index 0000000..bab74bb
--- /dev/null
+++ b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterOutputTest.java
@@ -0,0 +1,162 @@
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.logging
+ * ================================================================================
+ * Copyright © 2018 Amdocs
+ * All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.logging.ref.slf4j;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import javax.xml.bind.DatatypeConverter;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.MDC;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.testng.annotations.AfterSuite;
+import org.testng.annotations.BeforeSuite;
+import org.testng.annotations.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.StringContains.containsString;
+import static org.hamcrest.number.OrderingComparison.greaterThan;
+
+/**
+ * Smoketest output, though the embedded configuration isn't necessarily
+ * canonical.
+ *
+ * <p>There are more comprehensive tests in the <tt>logging-slf4j-demo</tt>
+ * project.</p>
+ */
+public class ONAPLogAdapterOutputTest {
+
+    /** Temporary directory into which logfiles are written. */
+    private static File sDir;
+
+    @BeforeSuite
+    public static void setUp() throws Exception {
+        sDir = Files.createTempDirectory(ONAPLogAdapterOutputTest.class.getName()).toFile();
+        System.getProperties().setProperty("SLF4J_OUTPUT_DIRECTORY", sDir.getAbsolutePath());
+        LoggerFactory.getLogger(ONAPLogAdapterOutputTest.class).info("Starting.");
+    }
+
+    @AfterSuite
+    public static void tearDown() throws Exception {
+        LoggerFactory.getLogger(ONAPLogAdapterOutputTest.class).info("Ending.");
+        Thread.sleep(1000L);
+        if (sDir != null) {
+            System.err.println("Should be deleting [" + sDir.getAbsolutePath() + "]...");
+        }
+    }
+
+    @Test
+    public void testOutput() throws Exception {
+
+        assertThat(sDir, notNullValue());
+        assertThat(sDir.isDirectory(), is(true));
+
+        final String uuid = UUID.randomUUID().toString();
+        final String errorcode = UUID.randomUUID().toString();
+        final Logger logger = LoggerFactory.getLogger(ONAPLogAdapterOutputTest.class);
+
+        try {
+            MDC.put("uuid", uuid);
+            final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+            final ONAPLogAdapter.HttpServletRequestAdapter http
+                    = new ONAPLogAdapter.HttpServletRequestAdapter(new MockHttpServletRequest());
+            adapter.entering(http);
+            adapter.unwrap().warn("a_warning");
+            try {
+                throw new Exception("errorcode=" + errorcode);
+            }
+            catch (final Exception e) {
+                adapter.unwrap().error("an_error", e);
+            }
+
+            Thread.sleep(1000L);
+        }
+        finally {
+            MDC.clear();
+        }
+
+        final List<String> lines = new ArrayList<>();
+        for (final File f : sDir.listFiles()) {
+            try (BufferedReader reader = new BufferedReader(new FileReader(f))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    if (line.contains(uuid)) {
+                        lines.add(line);
+                    }
+                }
+            }
+        }
+
+        assertThat(lines.size(), is(3));
+
+        assertThat(lines.get(0), containsString("ENTRY"));
+        final String [] line0 = lines.get(0).split("\t", -1);
+        assertThat(line0.length, is(9));
+        DatatypeConverter.parseDateTime(line0[0]);
+        assertThat(line0[1].trim().length(), greaterThan(1));
+        assertThat(line0[2], is("INFO"));
+        assertThat(line0[3], is(this.getClass().getName()));
+        assertThat(line0[4], containsString("uuid=" + uuid));
+        assertThat(line0[5], is(""));
+        assertThat(line0[6], is(""));
+        assertThat(line0[7], is("ENTRY"));
+        System.err.println(lines.get(0));
+
+        assertThat(lines.get(1), not(containsString("ENTRY")));
+        assertThat(lines.get(1), containsString("a_warning"));
+        final String [] line1 = lines.get(1).split("\t", -1);
+        assertThat(line1.length, is(9));
+        DatatypeConverter.parseDateTime(line1[0]);
+        assertThat(line1[1].trim().length(), greaterThan(1));
+        assertThat(line1[2], is("WARN"));
+        assertThat(line1[3], is(this.getClass().getName()));
+        assertThat(line1[4], containsString("uuid=" + uuid));
+        assertThat(line1[5], is("a_warning"));
+        assertThat(line1[6], is(""));
+        assertThat(line1[7], is(""));
+        System.err.println(lines.get(1));
+
+        assertThat(lines.get(2), not(containsString("ENTRY")));
+        assertThat(lines.get(2), containsString("an_error"));
+        final String [] line2 = lines.get(2).split("\t", -1);
+        assertThat(line2.length, is(9));
+        DatatypeConverter.parseDateTime(line2[0]);
+        assertThat(line2[1].trim().length(), greaterThan(1));
+        assertThat(line2[2], is("ERROR"));
+        assertThat(line2[3], is(this.getClass().getName()));
+        assertThat(line2[4], containsString("uuid=" + uuid));
+        assertThat(line2[5], is("an_error"));
+        assertThat(line2[6], containsString("errorcode=" + errorcode));
+        assertThat(line2[7], is(""));
+        System.err.println(lines.get(2));
+    }
+}
diff --git a/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterTest.java b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterTest.java
new file mode 100644
index 0000000..ad22603
--- /dev/null
+++ b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterTest.java
@@ -0,0 +1,387 @@
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.logging
+ * ================================================================================
+ * Copyright © 2018 Amdocs
+ * All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.logging.ref.slf4j;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.MDC;
+import org.slf4j.event.Level;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.hamcrest.core.IsSame.sameInstance;
+
+/**
+ * Tests for {@link ONAPLogAdapter}.
+ */
+public class ONAPLogAdapterTest {
+
+    /**
+     * Ensure that MDCs are cleared after each testcase.
+     */
+    @AfterMethod
+    public void resetMDCs() {
+        MDC.clear();
+    }
+
+    /**
+     * Test nullcheck.
+     */
+    @Test
+    public void testCheckNotNull() {
+
+        ONAPLogAdapter.checkNotNull("");
+
+        try {
+            ONAPLogAdapter.checkNotNull(null);
+            Assert.fail("Should throw NullPointerException");
+        }
+        catch (final NullPointerException e) {
+
+        }
+    }
+
+    /**
+     * Test defaulting of nulls.
+     */
+    @Test
+    public void testDefaultToEmpty() {
+        assertThat(ONAPLogAdapter.defaultToEmpty("123"), is("123"));
+        assertThat(ONAPLogAdapter.defaultToEmpty(Integer.valueOf(1984)), is("1984"));
+        assertThat(ONAPLogAdapter.defaultToEmpty(null), is(""));
+    }
+
+    /**
+     * Test defaulting of nulls.
+     */
+    @Test
+    public void testDefaultToUUID() {
+        assertThat(ONAPLogAdapter.defaultToUUID("123"), is("123"));
+        UUID.fromString(ONAPLogAdapter.defaultToUUID(null));
+    }
+
+    /**
+     * Test ENTERING.
+     */
+    @Test
+    public void testEntering() {
+
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+        final MockHttpServletRequest http = new MockHttpServletRequest();
+        http.setRequestURI("uri123");
+        http.setServerName("local123");
+        http.setRemoteAddr("remote123");
+        http.addHeader("X-ONAP-RequestID", "request123");
+        http.addHeader("X-ONAP-InvocationID", "invocation123");
+        http.addHeader("X-ONAP-PartnerName", "partner123");
+
+        try {
+            adapter.getServiceDescriptor().setServiceName("uri123");
+            adapter.entering(http);
+            final Map<String, String> mdcs = MDC.getCopyOfContextMap();
+            assertThat(mdcs.get("RequestID"), is("request123"));
+            assertThat(mdcs.get("InvocationID"), is("invocation123"));
+            assertThat(mdcs.get("PartnerName"), is("partner123"));
+            assertThat(mdcs.get("ServiceName"), is("uri123"));
+            assertThat(mdcs.get("ServerFQDN"), is("local123"));
+            assertThat(mdcs.get("ClientIPAddress"), is("remote123"));
+        }
+        finally {
+            MDC.clear();
+        }
+    }
+
+    @Test
+    public void testSetServiceDescriptor() {
+        final ONAPLogAdapter.ServiceDescriptor override = new ONAPLogAdapter.ServiceDescriptor();
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+        final ONAPLogAdapter.ServiceDescriptor before = adapter.getServiceDescriptor();
+        adapter.setServiceDescriptor(override);
+        final ONAPLogAdapter.ServiceDescriptor after = adapter.getServiceDescriptor();
+        assertThat(after, not(sameInstance(before)));
+        assertThat(after, is(override));
+    }
+
+    @Test
+    public void testSetResponseDescriptor() {
+        final ONAPLogAdapter.ResponseDescriptor override = new ONAPLogAdapter.ResponseDescriptor();
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+        final ONAPLogAdapter.ResponseDescriptor before = adapter.getResponseDescriptor();
+        adapter.setResponseDescriptor(override);
+        final ONAPLogAdapter.ResponseDescriptor after = adapter.getResponseDescriptor();
+        assertThat(after, not(sameInstance(before)));
+        assertThat(after, is(override));
+    }
+
+    @Test
+    public void testUnwrap() {
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+        assertThat(adapter.unwrap(), is(logger));
+    }
+
+    /**
+     * Test EXITING.
+     */
+    @Test
+    public void testExiting() {
+
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+
+        try {
+            MDC.put("somekey", "somevalue");
+            assertThat(MDC.get("somekey"), is("somevalue"));
+            adapter.exiting();
+            assertThat(MDC.get("somekey"), nullValue());
+        }
+        finally {
+            MDC.clear();
+        }
+    }
+
+    /**
+     * Test INVOKE.
+     */
+    @Test
+    public void testInvokeSyncAsyncNull() {
+
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+
+        final UUID syncUUID = adapter.invoke(ONAPLogConstants.InvocationMode.SYNCHRONOUS);
+        assertThat(syncUUID, notNullValue());
+
+        final UUID asyncUUID = adapter.invoke(ONAPLogConstants.InvocationMode.SYNCHRONOUS);
+        assertThat(asyncUUID, notNullValue());
+
+        final UUID agnosticUUID = adapter.invoke((ONAPLogConstants.InvocationMode)null);
+        assertThat(agnosticUUID, notNullValue());
+
+    }
+
+    /**
+     * Test INVOKE, with RequestAdapter.
+     */
+    @Test
+    public void testInvokeWithAdapter() throws Exception {
+
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+
+        final Map<String, String> headers = new HashMap<>();
+        final ONAPLogAdapter.RequestBuilder builder = new ONAPLogAdapter.RequestBuilder<ONAPLogAdapter.RequestBuilder>() {
+            @Override
+            public ONAPLogAdapter.RequestBuilder setHeader(final String name, final String value) {
+                headers.put(name, value);
+                return this;
+            }
+        };
+
+        try {
+            final UUID uuid = adapter.invoke(builder, ONAPLogConstants.InvocationMode.SYNCHRONOUS);
+            assertThat(uuid, notNullValue());
+            assertThat(headers.get(ONAPLogConstants.Headers.INVOCATION_ID), is(uuid.toString()));
+            assertThat(headers.containsKey(ONAPLogConstants.Headers.PARTNER_NAME), is(true));
+            assertThat(headers.containsKey(ONAPLogConstants.Headers.REQUEST_ID), is(true));
+        }
+        finally {
+            MDC.clear();
+        }
+    }
+
+    /**
+     * Test INVOKE, with RequestAdapter.
+     */
+    @Test
+    public void testInvokeWithAdapterAndNull() throws Exception {
+
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+
+        final Map<String, String> headers = new HashMap<>();
+        final ONAPLogAdapter.RequestBuilder builder = new ONAPLogAdapter.RequestBuilder<ONAPLogAdapter.RequestBuilder>() {
+            @Override
+            public ONAPLogAdapter.RequestBuilder setHeader(final String name, final String value) {
+                headers.put(name, value);
+                return this;
+            }
+        };
+
+        try {
+            final UUID uuid = adapter.invoke(builder);
+            assertThat(uuid, notNullValue());
+            assertThat(headers.get(ONAPLogConstants.Headers.INVOCATION_ID), is(uuid.toString()));
+            assertThat(headers.containsKey(ONAPLogConstants.Headers.PARTNER_NAME), is(true));
+            assertThat(headers.containsKey(ONAPLogConstants.Headers.REQUEST_ID), is(true));
+        }
+        finally {
+            MDC.clear();
+        }
+    }
+
+    @Test
+    public void testHttpServletRequestAdapter() {
+
+        final UUID uuid = UUID.randomUUID();
+        final MockHttpServletRequest request = new MockHttpServletRequest();
+        request.addHeader("uuid", uuid.toString());
+        request.setRequestURI("/ctx0");
+        request.setServerName("srv0");
+
+        final ONAPLogAdapter.HttpServletRequestAdapter adapter
+                = new ONAPLogAdapter.HttpServletRequestAdapter(request);
+        assertThat(adapter.getHeader("uuid"), is(uuid.toString()));
+        assertThat(adapter.getRequestURI(), is("/ctx0"));
+        assertThat(adapter.getServerAddress(), is("srv0"));
+    }
+
+    @Test
+    public void testServiceDescriptor() {
+        final String uuid = UUID.randomUUID().toString();
+
+        final ONAPLogAdapter.ServiceDescriptor adapter
+                = new ONAPLogAdapter.ServiceDescriptor();
+        adapter.setServiceUUID(uuid);
+        adapter.setServiceName("name0");
+
+        assertThat(MDC.get(ONAPLogConstants.MDCs.SERVICE_NAME), nullValue());
+        assertThat(MDC.get(ONAPLogConstants.MDCs.INSTANCE_UUID), nullValue());
+
+        adapter.setMDCs();
+
+        assertThat(MDC.get(ONAPLogConstants.MDCs.SERVICE_NAME), is("name0"));
+        assertThat(MDC.get(ONAPLogConstants.MDCs.INSTANCE_UUID), is(uuid));
+    }
+
+    @Test
+    public void testResponseDescriptor() {
+        final String uuid = UUID.randomUUID().toString();
+
+        final ONAPLogAdapter.ResponseDescriptor adapter
+                = new ONAPLogAdapter.ResponseDescriptor();
+        adapter.setResponseCode("code0");
+        adapter.setResponseDescription("desc0");
+        adapter.setResponseSeverity(Level.INFO);
+        adapter.setResponseStatus(ONAPLogConstants.ResponseStatus.COMPLETED);
+
+        assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_CODE), nullValue());
+        assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_DESCRIPTION), nullValue());
+        assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_SEVERITY), nullValue());
+        assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_STATUS_CODE), nullValue());
+
+        adapter.setMDCs();
+
+        assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_CODE), is("code0"));
+        assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_DESCRIPTION), is("desc0"));
+        assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_SEVERITY), is("INFO"));
+        assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_STATUS_CODE), is("COMPLETED"));
+    }
+
+    /**
+     * Exercise the contract, for a caller that's happy to have their
+     * service name automatically derived. (This validates nothing
+     * and achieves nothing; it's just to provide an example of minimal usage).
+     */
+    @Test
+    public void testContract() {
+
+        // Note no wrapper around HttpServletRequest, which will work for
+        // most invocations (since they come via HTTP), but otherwise
+        // can implement your own RequestAdapter.
+
+        final Logger logger = LoggerFactory.getLogger(this.getClass());
+        final ONAPLogAdapter adapter = new ONAPLogAdapter(logger);
+        final MockHttpServletRequest http = new MockHttpServletRequest();
+
+        // Immediately log ENTERING marker, with global MDCs.
+
+        adapter.entering(http);
+        try {
+
+            // Generate (and log) an invocationID, then use it to
+            // invoke another component.
+
+            final RESTClient client = new RESTClient();             // implements ONAPLogAdapter.RequestBuilder<RESTClient>.
+            adapter.invoke(client, ONAPLogConstants.InvocationMode.SYNCHRONOUS);
+            final RESTRequest request = null;                       // TODO: build real request.
+            final RESTResponse response = client.execute(request);  // TODO: handle real response.
+
+            // Set response details prior to #exiting.
+            // (Obviously there'd be errorhandling, etc. IRL).
+
+            adapter.getResponseDescriptor()
+                    .setResponseCode((String)null)
+                    .setResponseSeverity(Level.INFO)
+                    .setResponseStatus(ONAPLogConstants.ResponseStatus.COMPLETED);
+        }
+        finally {
+
+            // Return, logging EXIT marker, with response MDCs.
+
+            adapter.exiting();
+        }
+    }
+
+    /**
+     * Dummy class, for example code.
+     */
+    static class RESTClient implements ONAPLogAdapter.RequestBuilder<RESTClient> {
+
+        @Override
+        public RESTClient setHeader(final String name, final String value) {
+            return null;
+        }
+
+        RESTResponse execute(RESTRequest request) {
+            return null;
+        }
+    }
+
+    /**
+     * Dummy class, for example code.
+     */
+    static class RESTRequest {
+
+    }
+
+    /**
+     * Dummy class, for example code.
+     */
+    static class RESTResponse {
+
+    }
+}
diff --git a/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogConstantsTest.java b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogConstantsTest.java
new file mode 100644
index 0000000..f6642f9
--- /dev/null
+++ b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogConstantsTest.java
@@ -0,0 +1,133 @@
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.logging
+ * ================================================================================
+ * Copyright © 2018 Amdocs
+ * All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.logging.ref.slf4j;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+
+/**
+ * Tests for {@link ONAPLogConstants}.
+ */
+public class ONAPLogConstantsTest {
+
+    @Test
+    public void testConstructors() throws Exception {
+        assertInaccessibleConstructor(ONAPLogConstants.class);
+        assertInaccessibleConstructor(ONAPLogConstants.MDCs.class);
+        assertInaccessibleConstructor(ONAPLogConstants.Markers.class);
+        assertInaccessibleConstructor(ONAPLogConstants.Headers.class);
+    }
+
+    @Test
+    public void testConstructorUnsupported() throws Exception {
+        try {
+            Constructor<?> c = ONAPLogConstants.class.getDeclaredConstructors()[0];
+            c.setAccessible(true);
+            c.newInstance();
+            Assert.fail("Should fail for hidden constructor.");
+        }
+        catch (final InvocationTargetException e) {
+            assertThat(e.getCause(), instanceOf(UnsupportedOperationException.class));
+        }
+    }
+
+    @Test
+    public void testHeaders() {
+        assertThat(ONAPLogConstants.Headers.REQUEST_ID, is("X-ONAP-RequestID"));
+        assertThat(ONAPLogConstants.Headers.INVOCATION_ID, is("X-ONAP-InvocationID"));
+        assertThat(ONAPLogConstants.Headers.PARTNER_NAME, is("X-ONAP-PartnerName"));
+    }
+
+    @Test
+    public void testMarkers() {
+        assertThat(ONAPLogConstants.Markers.ENTRY.toString(), is("ENTRY"));
+        assertThat(ONAPLogConstants.Markers.EXIT.toString(), is("EXIT"));
+        assertThat(ONAPLogConstants.Markers.INVOKE.toString(), is("INVOKE"));
+        assertThat(ONAPLogConstants.Markers.INVOKE_ASYNCHRONOUS.toString(), is("INVOKE [ ASYNCHRONOUS ]"));
+        assertThat(ONAPLogConstants.Markers.INVOKE_SYNCHRONOUS.toString(), is("INVOKE [ SYNCHRONOUS ]"));
+    }
+
+    @Test
+    public void testInvocationMode() {
+        assertThat(ONAPLogConstants.InvocationMode.SYNCHRONOUS.getMarker(),
+                is(ONAPLogConstants.Markers.INVOKE_SYNCHRONOUS));
+        assertThat(ONAPLogConstants.InvocationMode.ASYNCHRONOUS.getMarker(),
+                is(ONAPLogConstants.Markers.INVOKE_ASYNCHRONOUS));
+    }
+
+    @Test
+    public void testInvocationModeToString() {
+        assertThat(ONAPLogConstants.InvocationMode.SYNCHRONOUS.toString(),
+                is("SYNCHRONOUS"));
+    }
+
+    @Test
+    public void testResponseStatus() {
+        assertThat(ONAPLogConstants.ResponseStatus.COMPLETED.toString(), is("COMPLETED"));
+        assertThat(ONAPLogConstants.ResponseStatus.ERROR.toString(), is("ERROR"));
+    }
+
+    @Test
+    public void testMDCs() {
+
+        assertThat(ONAPLogConstants.MDCs.CLIENT_IP_ADDRESS.toString(), is("ClientIPAddress"));
+        assertThat(ONAPLogConstants.MDCs.SERVER_FQDN.toString(), is("ServerFQDN"));
+
+        assertThat(ONAPLogConstants.MDCs.ENTRY_TIMESTAMP.toString(), is("EntryTimestamp"));
+        assertThat(ONAPLogConstants.MDCs.INVOKE_TIMESTAMP.toString(), is("InvokeTimestamp"));
+
+        assertThat(ONAPLogConstants.MDCs.REQUEST_ID.toString(), is("RequestID"));
+        assertThat(ONAPLogConstants.MDCs.INVOCATION_ID.toString(), is("InvocationID"));
+        assertThat(ONAPLogConstants.MDCs.PARTNER_NAME.toString(), is("PartnerName"));
+        assertThat(ONAPLogConstants.MDCs.INSTANCE_UUID.toString(), is("InstanceUUID"));
+        assertThat(ONAPLogConstants.MDCs.SERVICE_NAME.toString(), is("ServiceName"));
+        assertThat(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME.toString(), is("TargetServiceName"));
+
+    }
+
+    static void assertInaccessibleConstructor(final Class<?> c) throws Exception {
+        try {
+            c.getDeclaredConstructors()[0].newInstance();
+            Assert.fail("Should fail for hidden constructor.");
+        }
+        catch (final IllegalAccessException e) {
+
+        }
+
+        try {
+            final Constructor<?> constructor = c.getDeclaredConstructors()[0];
+            constructor.setAccessible(true);
+            constructor.newInstance();
+            Assert.fail("Should fail even when invoked.");
+        }
+        catch (final InvocationTargetException e) {
+            assertThat(e.getCause(), instanceOf(UnsupportedOperationException.class));
+        }
+    }
+}
diff --git a/reference/logging-slf4j/src/test/java/testng.xml b/reference/logging-slf4j/src/test/java/testng.xml
new file mode 100644
index 0000000..7b31c26
--- /dev/null
+++ b/reference/logging-slf4j/src/test/java/testng.xml
@@ -0,0 +1,8 @@
+<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
+<suite name="org.onap.logging.ref.slf4j" verbose="9" thread-count="1" parallel="methods">
+    <test name="all" thread-count="1" enabled="true">
+        <packages>
+            <package name="org.onap.logging.ref.slf4j.*"/>
+        </packages>
+    </test>
+</suite>
\ No newline at end of file
diff --git a/reference/logging-slf4j/src/test/resources/logback.xml b/reference/logging-slf4j/src/test/resources/logback.xml
new file mode 100644
index 0000000..554d712
--- /dev/null
+++ b/reference/logging-slf4j/src/test/resources/logback.xml
@@ -0,0 +1,35 @@
+<configuration>
+
+    <property name="p_tim" value="%d{&quot;yyyy-MM-dd'T'HH:mm:ss.SSSXXX&quot;, UTC}"/>
+    <property name="p_lvl" value="%level"/>
+    <property name="p_log" value="%logger"/>
+    <property name="p_mdc" value="%replace(%replace(%mdc){'\t','\\\\t'}){'\n', '\\\\n'}"/>
+    <property name="p_msg" value="%replace(%replace(%msg){'\t', '\\\\t'}){'\n','\\\\n'}"/>
+    <property name="p_exc" value="%replace(%replace(%rootException){'\t', '\\\\t'}){'\n','\\\\n'}"/>
+    <property name="p_mak" value="%replace(%replace(%marker){'\t', '\\\\t'}){'\n','\\\\n'}"/>
+    <property name="p_thr" value="%thread"/>
+    <property name="pattern" value="%nopexception${p_tim}\t${p_thr}\t${p_lvl}\t${p_log}\t${p_mdc}\t${p_msg}\t${p_exc}\t${p_mak}\t%n"/>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>${pattern}</pattern>
+        </encoder>
+    </appender>
+
+    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+        <file>${SLF4J_OUTPUT_DIRECTORY}/output.log</file>
+        <encoder>
+            <pattern>${pattern}</pattern>
+        </encoder>
+    </appender>
+
+    <logger level="debug" name="org.onap.logging.ref.slf4j" additivity="false">
+        <appender-ref ref="STDOUT" />
+        <appender-ref ref="FILE" />
+    </logger>
+
+    <root level="error">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>