/*
* Copyright 2011 Google Inc.
*
* 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.
*/
package com.google.gwt.dev.util.log.speedtracer;
import com.google.gwt.dev.json.JsonArray;
import com.google.gwt.dev.json.JsonException;
import com.google.gwt.dev.json.JsonObject;
import com.google.gwt.dev.shell.DevModeSession;
import com.google.gwt.dev.shell.DevModeSessionTestUtil;
import com.google.gwt.dev.util.log.dashboard.SpeedTracerLoggerTestMockNotifier;
import com.google.gwt.dev.util.log.dashboard.SpeedTracerLoggerTestMockNotifier.DevModeEvent;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.EventType;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Format;
import junit.framework.TestCase;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.LinkedList;
import java.util.Properties;
/**
* Tests the SpeedTracerLogger class.
*/
public class SpeedTracerLoggerTest extends TestCase {
private static class DummyEventType implements EventType {
private final String color;
private final String name;
public DummyEventType(String name, String color) {
this.name = name;
this.color = color;
}
@Override
public String getColor() {
return color;
}
@Override
public String getName() {
return name;
}
}
private class TestLoggerThreadedThread extends Thread {
private final EventType event;
private final SpeedTracerLogger logger;
public TestLoggerThreadedThread(EventType event, SpeedTracerLogger logger) {
super();
this.event = event;
this.logger = logger;
}
@Override
public void run() {
for (int i = 0; i < MAX_EVENT_LOGS; i++) {
Event e = logger.startImpl(null, event);
logger.endImpl(e);
}
}
}
private static final EventType dummyOne = new DummyEventType("Larry", "Red");
private static final EventType dummyThree = new DummyEventType("Moe", "Blue");
private static final EventType dummyTwo = new DummyEventType("Curly", "Green");
private static final int MAX_EVENT_LOGS = 10000;
public void testSpeedTracerLogger() throws IOException, JsonException {
Writer writer = new StringWriter();
SpeedTracerLogger logger = new SpeedTracerLogger(writer, Format.HTML);
Event dummyOneEvent = logger.startImpl(null, dummyOne);
Event dummyTwoEvent = logger.startImpl(null, dummyTwo);
logger.endImpl(dummyTwoEvent);
Event dummyThreeEvent = logger.startImpl(null, dummyThree);
logger.endImpl(dummyThreeEvent);
logger.endImpl(dummyOneEvent);
logger.flush();
Reader jsonReader = extractJsonFromWriter(writer);
JsonObject parsedObject = JsonObject.parse(jsonReader);
assertTrue("dummyOne", compareJsonToEvent(parsedObject, dummyOne));
JsonObject dataObject = parsedObject.get("data").asObject();
assertNotNull(dataObject);
JsonArray childArray = parsedObject.get("children").asArray();
assertNotNull(childArray);
assertEquals(2, childArray.getLength());
JsonObject child = childArray.get(0).asObject();
assertTrue("dummyTwo", compareJsonToEvent(child, dummyTwo));
child = childArray.get(1).asObject();
assertTrue("dummyThree", compareJsonToEvent(child, dummyThree));
}
public void testSpeedTracerLoggerExtraData() throws IOException,
JsonException {
Writer writer = new StringWriter();
SpeedTracerLogger logger = new SpeedTracerLogger(writer, Format.HTML);
Event dummyOneEvent = logger.startImpl(null, dummyOne, "extraStart", "valueStart");
logger.addDataImpl("extraMiddle", "valueMiddle");
logger.endImpl(dummyOneEvent, "extraEnd", "valueEnd");
logger.flush();
Reader jsonReader = extractJsonFromWriter(writer);
JsonObject parsedObject = JsonObject.parse(jsonReader);
assertEquals("valueStart", parsedObject.get("data").asObject().get(
"extraStart").asString().getString());
assertEquals(
"valueMiddle",
parsedObject.get("data").asObject().get("extraMiddle").asString().getString());
assertEquals(
"valueEnd",
parsedObject.get("data").asObject().get("extraEnd").asString().getString());
}
public void testSpeedTracerLoggerMultiple() throws IOException, JsonException {
Writer writer = new StringWriter();
SpeedTracerLogger logger = new SpeedTracerLogger(writer, Format.HTML);
Event dummyOneEvent = logger.startImpl(null, dummyOne);
logger.endImpl(dummyOneEvent);
Event dummyTwoEvent = logger.startImpl(null, dummyTwo);
logger.endImpl(dummyTwoEvent);
Event dummyThreeEvent = logger.startImpl(null, dummyThree);
logger.endImpl(dummyThreeEvent);
logger.flush();
Reader jsonReader = extractJsonFromWriter(writer);
JsonObject dummyOneObject = JsonObject.parse(jsonReader).asObject();
JsonObject dummyTwoObject = JsonObject.parse(jsonReader).asObject();
JsonObject dummyThreeObject = JsonObject.parse(jsonReader).asObject();
assertTrue(compareJsonToEvent(dummyOneObject, dummyOne));
assertTrue(compareJsonToEvent(dummyTwoObject, dummyTwo));
assertTrue(compareJsonToEvent(dummyThreeObject, dummyThree));
}
public void testSpeedTracerLoggerThreaded() throws InterruptedException,
IOException {
final int NUM_THREADS = 3;
Writer writer = new StringWriter();
SpeedTracerLogger logger = new SpeedTracerLogger(writer, Format.HTML);
Thread threads[] = new Thread[NUM_THREADS];
threads[0] = new TestLoggerThreadedThread(dummyOne, logger);
threads[1] = new TestLoggerThreadedThread(dummyTwo, logger);
threads[2] = new TestLoggerThreadedThread(dummyThree, logger);
for (int i = 0; i < NUM_THREADS; i++) {
threads[i].start();
}
for (int i = 0; i < NUM_THREADS; i++) {
threads[i].join();
}
logger.flush();
BufferedReader jsonReader = extractJsonFromWriter(writer);
int tally[] = new int[NUM_THREADS];
for (int i = 0; i < MAX_EVENT_LOGS * NUM_THREADS; i++) {
JsonObject result = null;
try {
result = JsonObject.parse(jsonReader).asObject();
} catch (JsonException ex) {
fail("Failed to parse json after " + i + " iterations. "
+ ex.toString());
}
if (compareJsonToEvent(result, dummyOne)) {
tally[0]++;
} else if (compareJsonToEvent(result, dummyTwo)) {
tally[1]++;
} else if (compareJsonToEvent(result, dummyThree)) {
tally[2]++;
} else {
fail("Node with typeName "
+ result.get("typeName").asString().getString()
+ " doesn't match expected");
}
}
for (int i = 0; i < NUM_THREADS; i++) {
assertEquals("dummy" + i + " has the wrong number of logs.", tally[i],
MAX_EVENT_LOGS);
}
}
public void testSpeedTracerLoggerMarkTimeline() throws IOException, JsonException {
Writer writer = new StringWriter();
SpeedTracerLogger logger = new SpeedTracerLogger(writer, Format.RAW);
Event dummyOneEvent = logger.startImpl(null, dummyOne);
logger.markTimelineImpl("Test Message");
dummyOneEvent.end();
logger.flush();
// There should be no HTML in here
String logString = writer.toString();
BufferedReader jsonReader = new BufferedReader(new StringReader(logString));
JsonObject dummyOneObject = JsonObject.parse(jsonReader).asObject();
assertTrue(compareJsonToEvent(dummyOneObject, dummyOne));
JsonArray children = dummyOneObject.get("children").asArray();
assertEquals(1, children.getLength());
JsonObject markTimelineObject = children.get(0).asObject();
assertEquals(11.0, markTimelineObject.get("type").asNumber().getDecimal(), .001);
JsonObject dataObject = markTimelineObject.get("data").asObject();
assertEquals("json=" + logString, "Test Message",
dataObject.get("message").asString().getString());
}
public void testSpeedTracerLoggerRaw() throws IOException, JsonException {
Writer writer = new StringWriter();
SpeedTracerLogger logger = new SpeedTracerLogger(writer, Format.RAW);
Event dummyOneEvent = logger.startImpl(null, dummyOne);
dummyOneEvent.end();
logger.flush();
// There should be no HTML in here
String logString = writer.toString();
assertTrue(logString.trim().startsWith("{"));
assertTrue(logString.trim().endsWith("}"));
BufferedReader jsonReader = new BufferedReader(new StringReader(logString));
JsonObject dummyOneObject = JsonObject.parse(jsonReader).asObject();
assertTrue(compareJsonToEvent(dummyOneObject, dummyOne));
}
private boolean compareJsonToEvent(JsonObject jsonObject, EventType eventType) {
String typeName = jsonObject.get("typeName").asString().getString();
String color = jsonObject.get("color").asString().getString();
return typeName.equals(eventType.getName())
&& color.equals(eventType.getColor());
}
private BufferedReader extractJsonFromWriter(Writer writer)
throws IOException {
String jsonString = writer.toString();
assertTrue(jsonString.substring(0,5).toLowerCase().startsWith("<html"));
BufferedReader jsonReader = new BufferedReader(new StringReader(jsonString));
// Skip ahead to start of JSON
while (true) {
jsonReader.mark(16 * 1024);
String line = jsonReader.readLine();
if (line == null) {
fail("Didn't find start of JSON string");
}
if (line.startsWith("{")) {
jsonReader.reset();
break;
}
}
return jsonReader;
}
public void testSpeedTracerWhenOnlyDashboardEnabled() {
// backup system properties before making changes to them
Properties props = (Properties) System.getProperties().clone();
try {
// no logging to file!
System.clearProperty("gwt.speedtracerlog");
// we don't capture GC events in dashboard, so setting this will allow us
// to confirm that they *don't* show up in dashboard notices
System.setProperty("gwt.speedtracer.logGcTime", "yes");
// now enable the mock dashboard notifier
SpeedTracerLoggerTestMockNotifier notifier = SpeedTracerLoggerTestMockNotifier.enable();
// create "sessions"
DevModeSession session1 = DevModeSessionTestUtil.createSession("test1", "test", true);
DevModeSession session2 = DevModeSessionTestUtil.createSession("test2", "test", false);
// expected values (used in final assertions below)
LinkedList<DevModeEvent> expectedEvents = new LinkedList<DevModeEvent>();
LinkedList<DevModeSession> expectedSessions = new LinkedList<DevModeSession>();
Event evt1, evt2;
// test events with no session specified
evt1 = SpeedTracerLogger.start(DevModeEventType.MODULE_INIT, "k1", "v1", "k2", "v2");
// also test that child events aren't posted (only top-level events)
evt2 = SpeedTracerLogger.start(DevModeEventType.CLASS_BYTES_REWRITE);
evt2.end();
evt1.end();
// expect only first event
expectedEvents.add(new DevModeEvent(evt1));
expectedSessions.add(session1); // event should get "default" session
// now with session specified
evt1 = SpeedTracerLogger.start(session2, DevModeEventType.JAVA_TO_JS_CALL, "k1", "v1");
// also test that child events aren't posted (only top-level events)
evt2 = SpeedTracerLogger.start(DevModeEventType.CREATE_UI);
evt2.end();
evt1.end();
// expect only first event
expectedEvents.add(new DevModeEvent(evt1));
expectedSessions.add(session2);
evt1 = SpeedTracerLogger.start(session1, DevModeEventType.JS_TO_JAVA_CALL, "k1", "v1");
evt1.end();
expectedEvents.add(new DevModeEvent(evt1));
expectedSessions.add(session1);
// Finally, assert that the events and corresponding sessions sent to the
// notifier are exactly as expected
assertEquals("Events posted to dashboard do not match expected events!", expectedEvents,
notifier.getEventSequence());
// Collect sessions associated with each event
LinkedList<DevModeSession> actualSessions = new LinkedList<DevModeSession>();
for (DevModeEvent event : notifier.getEventSequence()) {
actualSessions.add(event.getDevModeSession());
}
// and confirm the sessions are correct
assertEquals("Events posted to dashboard are associated with incorrect sessions!",
expectedSessions, actualSessions);
} finally {
// restore system properties
System.setProperties(props);
}
}
}