2.4/dev/core/test/com/google/gwt/dev/util/log/speedtracer/SpeedTracerLoggerTest.java - gwt - Git at Google

 /*
  * 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);
     }
   }
 }
	/*
	* 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);
	}
	}
	}